Comment garantir l'exclusion mutuelle dans les goroutines simultanées à l'aide de mutex ?

Exclusion mutuelle dans les goroutines simultanées : parvenir à l'isolement du code

Dans la programmation simultanée, il est crucial d'avoir des mécanismes en place pour empêcher plusieurs goroutines de s'exécuter le même code simultanément. Cela garantit l'intégrité des données et évite tout comportement inattendu.

Considérez le scénario suivant :

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

Ici, pendant que les sections de code entre les marqueurs Do Something s'exécutent, nous voulons empêcher le contrôle de passer à d'autres goroutines. Par exemple, lorsque Routine1 exécute la partie située dans les étoiles, Routine2 et Routine3 doivent être bloquées.

Réaliser une exclusion mutuelle avec WaitGroup

Une approche pour imposer l'exclusion mutuelle consiste à utilisez un sync.WaitGroup. Cependant, cette technique n'est pas applicable dans ce scénario car elle n'a pas la capacité de bloquer les goroutines de manière sélective.

Utiliser les mutex pour l'isolement

Une solution plus efficace consiste à utiliser la synchronisation .Mutex. Un mutex garantit qu'un seul goroutine peut le posséder à un moment donné. Voici comment implémenter l'exclusion mutuelle à l'aide de 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>

Dans ce code :

• Nous définissons un mutex pour chaque goroutine (mutex1, mutex2, mutex3).
• Dans chaque goroutine (Routine1, Routine2, Routine3), nous verrouillons notre mutex au début et le déverrouillons à la fin, protégeant ainsi la section critique à l'intérieur.
• Quand une goroutine tente de verrouiller un mutex qui est déjà verrouillé par une autre goroutine, il se bloquera jusqu'à ce que le mutex soit disponible.

En conséquence, les instructions d'impression à l'intérieur de chaque goroutine s'exécuteront une à la fois, garantissant qu'aucune autre goroutine ne pourra accéder à ces lignes jusqu'à ce que la goroutine actuelle a libéré son verrou.

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!