Bagaimanakah saya boleh mencapai pengecualian bersama dalam goroutine serentak menggunakan WaitGroup?

Saling Pengecualian Goroutine Serentak Menggunakan WaitGroup

Dalam kod anda, anda mempunyai tiga goroutine serentak yang perlu dilaksanakan tanpa gangguan antara satu sama lain semasa bahagian tertentu kod mereka. Konsep ini dikenali sebagai pengecualian bersama dan ia memastikan bahawa hanya satu goroutine boleh melaksanakan bahagian kritikal kod pada satu masa.

Untuk mencapai pengecualian bersama menggunakan WaitGroup, anda boleh mengikuti langkah berikut:

1. Buat Mutex untuk Setiap Goroutine Serentak: Mutex ialah mekanisme penguncian yang membenarkan hanya satu goroutine memperoleh kunci pada satu masa. Cipta mutex berasingan untuk setiap goroutine yang perlu melaksanakan bahagian kritikalnya secara eksklusif.
2. Peroleh Mutex Sebelum Memasuki Bahagian Kritikal: Sebelum melaksanakan bahagian kritikal kod dalam setiap goroutine, panggil Kaedah Lock() pada mutex yang sepadan. Operasi ini akan menyekat goroutine sehingga mutex diperolehi.
3. Lepaskan Mutex Selepas Meninggalkan Bahagian Kritikal: Selepas menyelesaikan pelaksanaan bahagian kritikal, lepaskan mutex dengan memanggil Unlock() kaedah. Ini membolehkan gorouti lain memperoleh mutex dan memasuki bahagian kritikalnya.
4. Gunakan WaitGroup untuk Menunggu Selesai: Buat WaitGroup untuk menjejaki penyiapan semua gorouti. Setiap goroutine harus memanggil kaedah Done() WaitGroup selepas menyelesaikan pelaksanaannya. Goroutine utama harus menunggu semua goroutine selesai menggunakan kaedah Wait() WaitGroup.

Berikut ialah contoh yang melaksanakan langkah di atas:

<code class="go">package main

import (
    "fmt"
    "sync"
)

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

func Routine1() {
    mutex1.Lock()
    defer mutex1.Unlock()

    // Do something
    for i := 0; i < 200; i++ {
        mutex2.Lock()
        mutex3.Lock()
        fmt.Println("value of z")
        mutex2.Unlock()
        mutex3.Unlock()
    }
    // Do something
}

func Routine2() {
    mutex2.Lock()
    defer mutex2.Unlock()

    // Do something
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        mutex3.Lock()
        fmt.Println("value of z")
        mutex1.Unlock()
        mutex3.Unlock()
    }
    // Do something
}

func Routine3() {
    mutex3.Lock()
    defer mutex3.Unlock()

    // Do something
    for i := 0; i < 200; i++ {
        mutex1.Lock()
        mutex2.Lock()
        fmt.Println("value of z")
        mutex1.Unlock()
        mutex2.Unlock()
    }
    // Do something
}

func main() {
    wg.Add(3)
    go Routine1()
    go Routine2()
    go Routine3()
    wg.Wait()
}</code>

Dalam contoh ini , bahagian kritikal setiap goroutine ialah gelung di mana ia melaksanakan fmt.Println("nilai z"). Mutexes memastikan bahawa hanya satu goroutine boleh melaksanakan bahagian ini pada satu masa. WaitGroup memastikan bahawa goroutine utama menunggu semua goroutine selesai sebelum keluar.

Atas ialah kandungan terperinci Bagaimanakah saya boleh mencapai pengecualian bersama dalam goroutine serentak menggunakan WaitGroup?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!