Bagaimana untuk Memastikan Pengecualian Bersama dalam Goroutine Serentak Menggunakan Mutexes?

Pengecualian Bersama dalam Goroutine Serentak: Mencapai Pengasingan Kod

Dalam pengaturcaraan serentak, adalah penting untuk mempunyai mekanisme untuk menghalang berbilang goroutin daripada dilaksanakan kod yang sama serentak. Ini memastikan integriti data dan menghalang tingkah laku yang tidak dijangka.

Pertimbangkan senario berikut:

<code class="go">Routine 1 {
do something

*Send int to Routine 2
Send int to Routine 3
Print Something
Print Something*

do something
}

Routine 2 {
do something

*Send int to Routine 1
Send int to Routine 3
Print Something
Print Something*

do something
}

Routine 3 {
do something

*Send int to Routine 1
Send int to Routine 2
Print Something
Print Something*

do something
}</code>

Di sini, semasa bahagian kod antara penanda melakukan sesuatu sedang dilaksanakan, kami ingin menghalang kawalan daripada mengalir ke goroutine lain. Contohnya, apabila Routine1 melaksanakan bahagian dalam bintang, Routine2 dan Routine3 harus disekat.

Mencapai Pengecualian Bersama dengan WaitGroup

Satu pendekatan untuk menguatkuasakan pengecualian bersama ialah dengan gunakan penyegerakan.WaitGroup. Walau bagaimanapun, teknik ini tidak boleh digunakan dalam senario ini kerana ia tidak mempunyai keupayaan untuk menyekat goroutin secara selektif.

Menggunakan Mutexes untuk Pengasingan

Penyelesaian yang lebih berkesan ialah menggunakan penyegerakan .Mutex. Mutex memastikan bahawa hanya satu goroutine boleh memilikinya pada bila-bila masa. Begini cara untuk melaksanakan pengecualian bersama menggunakan mutex:

<code class="go">package main

import (
    "fmt"
    "sync"
)

var (
    mutex1, mutex2, mutex3 sync.Mutex
)

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

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

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

func main() {
    go Routine1()
    go Routine2()
    Routine3()
}</code>

Dalam kod ini:

• Kami mentakrifkan mutex untuk setiap goroutine (mutex1, mutex2, mutex3).
• Dalam setiap goroutine (Rutin1, Rutin2, Rutin3), kami mengunci muteks kami pada permulaan dan membuka kuncinya pada penghujungnya, melindungi bahagian kritikal di dalamnya.
• Apabila goroutine cuba mengunci mutex yang sudah dikunci oleh goroutine lain, ia akan menyekat sehingga mutex tersedia.

Akibatnya, pernyataan cetakan di dalam setiap goroutine akan dilaksanakan satu demi satu, memastikan tiada goroutine lain boleh mengakses baris tersebut sehingga goroutine semasa telah melepaskan kuncinya.

Atas ialah kandungan terperinci Bagaimana untuk Memastikan Pengecualian Bersama dalam Goroutine Serentak Menggunakan Mutexes?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!