Bagaimanakah WaitGroups dan Mutexes boleh digunakan untuk mencapai pengecualian bersama antara goroutin serentak dalam Go?

Pengecualian Bersama Goroutine Serentak Menggunakan WaitGroup dan Mutexes

Untuk mencapai pengecualian bersama goroutin serentak dalam Go, di mana hanya satu goroutine pada satu masa boleh melaksanakan kod tertentu, kami boleh memanfaatkan gabungan WaitGroup dan mutex.

WaitGroup ialah primitif penyegerakan yang membolehkan kami menunggu sekumpulan goroutine menyelesaikan pelaksanaannya sebelum meneruskan. Mutexes, sebaliknya, menyediakan mekanisme kunci pengecualian bersama, memastikan bahagian kritikal kod tidak dilaksanakan oleh berbilang goroutine secara serentak.

Pertimbangkan contoh kod berikut:

<code class="go">package main

import (
    "fmt"
    "rand"
    "sync"
)

var (
    mutex1, mutex2, mutex3 sync.Mutex
    wg sync.WaitGroup
)

func Routine1() {
    mutex1.Lock()
    defer mutex1.Unlock() // Ensure mutex is always unlocked before returning
    // do something

    // Sending and printing events should be mutually exclusive
    for i := 0; i < 200; i++ {
        mutex2.Lock()
        defer mutex2.Unlock()
        mutex3.Lock()
        defer mutex3.Unlock()
        fmt.Println("value of z")
    }

    // do something
}

func Routine2() {
    mutex2.Lock()
    defer mutex2.Unlock()
    // do something

    // Sending and printing events should be mutually exclusive
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        defer mutex1.Unlock()
        mutex3.Lock()
        defer mutex3.Unlock()
        fmt.Println("value of z")
    }

    // do something
}

func Routine3() {
    mutex3.Lock()
    defer mutex3.Unlock()
    // do something

    // Sending and printing events should be mutually exclusive
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        defer mutex1.Unlock()
        mutex2.Lock()
        defer mutex2.Unlock()
        fmt.Println("value of z")
    }

    // do something
}

func main() {
    wg.Add(3)
    go Routine1()
    go Routine2()
    Routine3()
    wg.Wait() // Wait for all goroutines to complete
}</code>

Dalam kod ini, kami mempunyai tiga gorouti berasingan (Rutin1, Rutin2 dan Rutin3) yang kesemuanya melaksanakan operasi tertentu secara serentak. Walau bagaimanapun, kami ingin memastikan bahagian tertentu kod (peristiwa penghantaran dan pencetakan) dilaksanakan tanpa gangguan daripada goroutine lain.

Kami mencapai ini dengan menggunakan mutex. Kami mentakrifkan tiga mutex (mutex1, mutex2, dan mutex3) dan memperoleh kunci untuk mutex yang sesuai sebelum melaksanakan bahagian kritikal. Apabila mutex dikunci oleh satu goroutine, goroutine lain yang cuba mendapatkan kunci yang sama akan disekat sehingga ia tersedia.

Dengan mengunci dan membuka kunci mutex yang sesuai, kami memastikan hanya satu goroutine boleh melaksanakan bahagian kritikal pada bila-bila masa. Ini menghalang pelaksanaan serentak bahagian kod tersebut dan mengekalkan pengecualian bersama antara goroutine.

Akhir sekali, kami menggunakan WaitGroup untuk memastikan bahawa fungsi utama tidak terkeluar sehingga ketiga-tiga goroutine telah menyelesaikan pelaksanaannya. Ini membolehkan kami menyegerakkan goroutine dan mengawal aliran program.

Atas ialah kandungan terperinci Bagaimanakah WaitGroups dan Mutexes boleh digunakan untuk mencapai pengecualian bersama antara goroutin serentak dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!