Comment puis-je obtenir une exclusion mutuelle dans des goroutines simultanées à l'aide de WaitGroup ?

Exclusion mutuelle de goroutines simultanées à l'aide de WaitGroup

Dans votre code, vous avez trois goroutines concurrentes qui doivent s'exécuter sans interférence les unes des autres pendant sections spécifiques de leur code. Ce concept est connu sous le nom d'exclusion mutuelle et garantit qu'une seule goroutine peut exécuter une section critique de code à la fois.

Pour obtenir une exclusion mutuelle à l'aide de WaitGroup, vous pouvez suivre ces étapes :

1. Créer un mutex pour chaque goroutine simultanée : Un mutex est un mécanisme de verrouillage qui permet à une seule goroutine d'acquérir un verrou à la fois. Créez un mutex distinct pour chaque goroutine qui doit exécuter sa section critique exclusivement.
2. Acquérir le mutex avant d'entrer dans la section critique : Avant d'exécuter la section critique du code dans chaque goroutine, appelez le Méthode Lock() sur le mutex correspondant. Cette opération bloquera la goroutine jusqu'à ce que le mutex soit acquis.
3. Libérez le mutex après avoir quitté la section critique : Après avoir terminé l'exécution de la section critique, libérez le mutex en appelant Unlock() méthode. Cela permet à d'autres goroutines d'acquérir le mutex et d'accéder à leurs sections critiques.
4. Utilisez WaitGroup pour attendre l'achèvement : Créez un WaitGroup pour suivre l'achèvement de toutes les goroutines. Chaque goroutine doit appeler la méthode Done() du WaitGroup après avoir terminé son exécution. La goroutine principale doit attendre que toutes les goroutines se terminent en utilisant la méthode Wait() du WaitGroup.

Voici un exemple qui implémente les étapes ci-dessus :

<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>

Dans cet exemple , la section critique de chaque goroutine est la boucle où elle exécute fmt.Println("value of z"). Les mutex garantissent qu'un seul goroutine peut exécuter cette section à la fois. Le WaitGroup garantit que la goroutine principale attend que toutes les goroutines soient terminées avant de quitter.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!