Bagaimana untuk melaksanakan keselamatan serentak dalam bahasa Go?

Dengan perkembangan teknologi komputer yang berterusan, kita mesti beralih daripada benang tunggal kepada berbilang benang untuk pemprosesan program. Berbanding dengan model pemprosesan serentak tradisional, mekanisme pemprosesan serentak yang berkuasa bagi bahasa Go telah menarik perhatian ramai pembangun. Bahasa Go menyediakan mekanisme pelaksanaan ringan yang menjadikan kod serentak tulen lebih mudah untuk ditulis.

Walau bagaimanapun, tidak dapat dielakkan bahawa persekitaran berbilang benang akan membawa banyak keadaan perlumbaan. Apabila beberapa utas cuba membaca dan menulis sumber dikongsi yang sama pada masa yang sama, hasil yang tidak dijangka mungkin berlaku disebabkan ketidakpastian susunan pelaksanaan. Keadaan Perlumbaan adalah salah satu masalah yang paling ditakuti oleh pembangun.

Untuk mengelakkan potensi masalah dalam pemprosesan serentak, bahasa Go menyediakan pelbagai jenis perpustakaan standard: penyegerakan. Artikel ini akan memperkenalkan mekanisme untuk mencapai keselamatan serentak melalui perpustakaan penyegerakan.

Mutex dan RWMutex

mutex ialah mekanisme yang paling biasa digunakan. Pada bila-bila masa, hanya satu coroutine boleh mendapatkan objek mutex, dan coroutine lain perlu menunggu coroutine sebelumnya melepaskan kunci sebelum mereka boleh meneruskan pelaksanaan. Mutex boleh digunakan untuk melindungi sumber yang dikongsi supaya kod boleh berjalan dengan selamat dan stabil.

RWMutex ialah satu lagi jenis kunci mutex, yang bersamaan dengan lanjutan mutex dalam bidang membaca dan menulis. RWMutex mengandungi dua pembilang: pembilang baca dan pembilang tulis.

• Apabila coroutine membaca masih menjalankan operasi membaca, operasi menulis akan dikunci dan menunggu operasi membaca tamat.
• Apabila coroutine menulis memanggil operasi kunci, semua operasi baca dan tulis berterusan coroutine akan dikunci.

Mekanisme ini memastikan bahawa berbilang coroutine boleh melakukan operasi baca pada masa yang sama dan hanya satu coroutine boleh melakukan operasi tulis.

var rwMutex sync.RWMutex
var count int
func read() {
    rwMutex.RLock()
    defer rwMutex.RUnlock()

    fmt.Println(count)
}

func write() {
    rwMutex.Lock()
    defer rwMutex.Unlock()

    count++
}

Dalam kod contoh di atas, kami menggunakan kunci jenis RWMutex untuk melindungi operasi baca dan tulis pembolehubah kiraan. Apabila benang memanggil fungsi write(), pembilang tulis dikunci dan semua coroutine lain disekat daripada membaca dan menulis. Apabila benang memanggil fungsi baca(), pembilang baca akan dikunci dan coroutine lain akan dibenarkan untuk melakukan operasi baca.

WaitGroup

WaitGroup digunakan untuk menunggu sekumpulan coroutine menyelesaikan pelaksanaan. Katakan kita mempunyai n coroutine yang perlu dilaksanakan, maka dalam coroutine utama, kita perlu memanggil waitGroup.Add(n). WaitGroup.Done() dipanggil selepas setiap coroutine telah menyelesaikan pelaksanaan.

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(n int) {
            fmt.Println("goroutine ", n)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

Dalam contoh ini, kami menggunakan WaitGroup untuk menunggu pelaksanaan setiap goroutine, dan akhirnya menunggu semua goroutine selesai sebelum menamatkan proses pelaksanaan utama.

Cond

Apabila berbilang coroutine perlu berhenti atau melakukan beberapa operasi tertentu, kita boleh menggunakan Cond. Ia adalah perkara biasa untuk menggunakan Cond bersama-sama dengan kunci dan WaitGroup. Ia membenarkan goroutine menyekat secara serentak sehingga pembolehubah keadaan berubah.

var cond = sync.NewCond(&sync.RWMutex{})

func printOddNumbers() {
    for i := 0; i < 10; i++ {
        cond.L.Lock()
        if i%2 == 1 {
            fmt.Println(i)
            cond.Signal()
        } else {
            cond.Wait()
        }
        cond.L.Unlock()
    }
}

func printEvenNumbers() {
    for i := 0; i < 10; i++ {
        cond.L.Lock()
        if i%2 == 0 {
            fmt.Println(i)
            cond.Signal()
        } else {
            cond.Wait()
        }
        cond.L.Unlock()
    }
}

Dalam contoh kod di atas, kami menggunakan Cond untuk memastikan nombor genap dan nombor ganjil dikeluarkan secara berasingan. Setiap coroutine menggunakan sync.Mutex untuk mengunci goroutine dan tunggu coroutine lain mengakses pembolehubah kongsi dahulu dan kemudian memantau nilai pembolehubah.

Sekali

Dalam sesetengah kes, anda perlu memastikan bahawa operasi tertentu dilakukan sekali sahaja, seperti membaca fail konfigurasi sekali sahaja atau memulakan keadaan global sekali sahaja. Jenis bahasa Go sync.Once dilahirkan untuk tujuan ini. Apabila fungsi dipanggil buat kali pertama ia akan melaksanakan kod di dalamnya, dan tidak akan dilaksanakan lagi selepas panggilan berikutnya.

var once sync.Once

func doSomething() {
    once.Do(func() {
        fmt.Println("Do something")
    })
}

Dalam contoh di atas, kami menggunakan penyegerakan.Sekali untuk melaksanakan fungsi doSomething dengan selamat. Kali pertama doSomething dipanggil, fungsi akan dilaksanakan sekali sahaja menggunakan sekali.Do().

Kesimpulan

Dalam artikel ini, kami memperkenalkan kunci dan mekanisme yang biasa digunakan dalam bahasa Go untuk memastikan keselamatan kod serentak. Jenis Mutex, RWMutex, WaitGroup, Cond dan Once menggunakan perpustakaan penyegerakan semuanya sangat berkuasa dan boleh digunakan untuk mereka bentuk program serentak yang selamat dan cekap. Memandangkan mekanisme konkurensi terus berkembang, memahami kemajuan terkini dalam pengaturcaraan serentak adalah kunci untuk memastikan kemahiran pembangunan anda berdaya saing.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan keselamatan serentak dalam bahasa Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!