Comment les verrous Mutex peuvent-ils être utilisés pour obtenir une exclusion mutuelle dans des Goroutines simultanées ?

Exclusion mutuelle des goroutines simultanées avec des verrous mutex

Dans votre code, vous voulez vous assurer que les sections de code spécifiques de chaque goroutine s'exécutent de manière isolée . Cela empêche l'exécution simultanée de ces sections par d'autres goroutines. Voici comment l'exclusion mutuelle peut être obtenue à l'aide de verrous mutex :

Le schéma de code fourni démontre le flux de goroutines et la nécessité d'une exclusion mutuelle. Vous souhaitez empêcher l'exécution de passer à d'autres goroutines pendant que certains événements sont exécutés dans une goroutine.

Pour implémenter cela, un verrou mutex peut être utilisé. Un mutex garantit qu'une seule goroutine peut accéder à une ressource partagée à un moment donné. Voici une version légèrement modifiée de votre code qui utilise des mutex pour l'exclusion mutuelle :

<code class="go">package main

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

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

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()
    wg.Done()
}

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()
    wg.Done()
}

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()
    wg.Done()
}

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

Voici comment ce code mis à jour réalise l'exclusion mutuelle :

1. Un verrou mutex est créé pour chaque goroutine (mutex1, mutex2 et mutex3).
2. Lorsqu'une goroutine doit accéder à la section critique (où une exclusion mutuelle est requise), elle verrouille le mutex correspondant.
3. Tandis que le mutex est verrouillé par une goroutine, les autres goroutines qui tentent d'accéder au même mutex seront bloquées jusqu'à ce qu'il soit déverrouillé.
4. Une fois la section critique terminée, la goroutine déverrouille le mutex, permettant à d'autres goroutines d'y accéder.

Cette implémentation garantit que les sections de code spécifiées dans chaque goroutine s'exécutent de manière isolée, empêchant l'exécution simultanée d'autres goroutines.

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!