How can WaitGroups and Mutexes be used to achieve mutual exclusion between concurrent goroutines in Go?

Mutual Exclusion of Concurrent Goroutines Using WaitGroup and Mutexes

To achieve mutual exclusion of concurrent goroutines in Go, where only one goroutine at a time can execute certain code, we can leverage a combination of WaitGroup and mutexes.

WaitGroup is a synchronization primitive that allows us to wait for a group of goroutines to complete their execution before proceeding. Mutexes, on the other hand, provide a mutual exclusion lock mechanism, ensuring that a critical section of code is not executed by multiple goroutines simultaneously.

Consider the following example code:

<code class="go">package main

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

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

func Routine1() {
    mutex1.Lock()
    defer mutex1.Unlock() // Ensure mutex is always unlocked before returning
    // do something

    // Sending and printing events should be mutually exclusive
    for i := 0; i &lt; 200; i++ {
        mutex2.Lock()
        defer mutex2.Unlock()
        mutex3.Lock()
        defer mutex3.Unlock()
        fmt.Println("value of z")
    }

    // do something
}

func Routine2() {
    mutex2.Lock()
    defer mutex2.Unlock()
    // do something

    // Sending and printing events should be mutually exclusive
    for i := 0; i &lt; 200; i++ {
        mutex1.Lock()
        defer mutex1.Unlock()
        mutex3.Lock()
        defer mutex3.Unlock()
        fmt.Println("value of z")
    }

    // do something
}

func Routine3() {
    mutex3.Lock()
    defer mutex3.Unlock()
    // do something

    // Sending and printing events should be mutually exclusive
    for i := 0; i &lt; 200; i++ {
        mutex1.Lock()
        defer mutex1.Unlock()
        mutex2.Lock()
        defer mutex2.Unlock()
        fmt.Println("value of z")
    }

    // do something
}

func main() {
    wg.Add(3)
    go Routine1()
    go Routine2()
    Routine3()
    wg.Wait() // Wait for all goroutines to complete
}</code>

In this code, we have three separate goroutines (Routine1, Routine2, and Routine3) that all perform certain operations concurrently. However, we want to ensure that certain sections of the code (the sending and printing events) are executed without interference from other goroutines.

We achieve this by utilizing mutexes. We define three mutexes (mutex1, mutex2, and mutex3) and acquire the lock for the appropriate mutex before executing the critical section. When a mutex is locked by one goroutine, other goroutines attempting to acquire the same lock will be blocked until it becomes available.

By locking and unlocking the appropriate mutexes, we ensure that only one goroutine can execute the critical section at any given time. This prevents simultaneous execution of those code sections and maintains mutual exclusion among the goroutines.

Finally, we employ a WaitGroup to ensure that the main function does not exit until all three goroutines have completed their execution. This allows us to synchronize the goroutines and control the flow of the program.

The above is the detailed content of How can WaitGroups and Mutexes be used to achieve mutual exclusion between concurrent goroutines in Go?. For more information, please follow other related articles on the PHP Chinese website!