How can you achieve mutual exclusion in concurrent Goroutines using Mutexes?

Mutual Exclusion in Concurrent Goroutines Using Mutex

The concept of mutual exclusion governs the simultaneous execution of functions or codeblocks in a program. In a concurrent programming environment, where multiple routines execute independently, maintaining mutual exclusion is crucial for ensuring correctness and preventing conflicts.

Problem:
Consider a scenario with three concurrent goroutines (Routine 1, 2, and 3), which exchange data and perform printing operations. The goal is to ensure that while a specific section of code in any goroutine is executing, execution in other goroutines is halted, until this section completes.

Solution Using Mutex:
Mutexes, a fundamental synchronization primitive, can be employed to achieve mutual exclusion in goroutines. Mutexes provide a locking mechanism that allows only one goroutine to access a critical section of code at a time.

In the provided code snippet, three mutexes (mutex1, mutex2, and mutex3) have been introduced:

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

Each goroutine acquires the appropriate mutex before executing the critical section, as shown in the revised code:

func Routine1() {
    mutex1.Lock()
    // do something
    ...
    // do something
    mutex1.Unlock()
    ...
}

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

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

• Routine1 acquires mutex1 while executing the critical section, blocking other routines from accessing this section.
• Routine2 acquires mutex2, ensuring exclusive execution of its critical section.
• Routine3 acquires mutex3 to control access to its critical section.

Wait Group and Synchronization:
Additionally, a wait group (wg) has been utilized to synchronize the goroutines:

wg.Add(3)
go Routine1()
go Routine2()
Routine3()
wg.Wait()

• The Add method increments the wait group's counter by 3, indicating that three goroutines are about to execute.
• The go statement запускает Routine1 and Routine2 concurrently.
• Routine3 is executed in the current thread.
• The Wait method blocks until the wait group counter reaches zero, ensuring that all goroutines have completed execution before the main function proceeds.

Result:
With this implementation, the execution of critical sections in the goroutines will be mutually exclusive. As a result, the printing operations in each routine will not overlap or be interleaved, preventing race conditions and producing the expected output.

The above is the detailed content of How can you achieve mutual exclusion in concurrent Goroutines using Mutexes?. For more information, please follow other related articles on the PHP Chinese website!