Master the Go language synchronization mechanism: improve concurrent programming skills

Go language, as a concurrent programming language, provides a rich synchronization mechanism to help developers deal with concurrency issues. Mastering these synchronization mechanisms is crucial to improving your concurrent programming skills. This article will illustrate some common synchronization mechanisms in the Go language through specific code examples to help readers better understand and use these mechanisms.

1. Mutex (Mutex)

Mutex is a basic synchronization mechanism used to protect shared resources from being accessed by multiple goroutines at the same time. The following is a simple mutex lock example:

package main

import (
    "fmt"
    "sync"
)

var (
    counter int
    mutex   sync.Mutex
)

func incrementCounter() {
    mutex.Lock()
    defer mutex.Unlock()
    counter++
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            incrementCounter()
        }()
    }
    wg.Wait()
    fmt.Println("Counter:", counter)
}

In the above example, sync.Mutex is used to protect concurrent access to the counter variable to ensure that each Only one goroutine can execute the incrementCounter() function.

2. Channel

Channel is a mechanism used to communicate between goroutines in the Go language. It can be used to transfer data and control concurrency. Here is a simple channel example:

package main

import "fmt"

func sendData(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch)
}

func receiveData(ch <-chan int) {
    for v := range ch {
        fmt.Println("Received:", v)
    }
}

func main() {
    ch := make(chan int)
    go sendData(ch)
    receiveData(ch)
}

In the above example, data is passed between two goroutines through the channel ch. The sendData() function sends data to the channel, the receiveData() function receives data from the channel, and traverses the data in the channel through range.

3. Condition variable (Cond)

Condition variable is a mechanism for waiting or signaling between goroutines. It is often used to implement some complex synchronization logic. The following is a simple condition variable example:

package main

import (
    "fmt"
    "sync"
)

var (
    done  bool
    cond  *sync.Cond
    mutex sync.Mutex
)

func worker1() {
    mutex.Lock()
    for !done {
        cond.Wait()
    }
    mutex.Unlock()
    fmt.Println("Worker 1: Done")
}

func worker2() {
    mutex.Lock()
    done = true
    cond.Signal()
    mutex.Unlock()
    fmt.Println("Worker 2: Signaled")
}

func main() {
    cond = sync.NewCond(&mutex)
    go worker1()
    go worker2()
}

In the above example, the relationship between two goroutines is implemented through the condition variable cond and the mutex lock mutex synchronization. worker1()The function waits for the done variable to be true before continuing execution, worker2()Function settingsdone The variable is true and sends the signal to worker1().

Through the above examples, I hope readers can have a deeper understanding of the synchronization mechanism in the Go language, and use it flexibly in actual projects to improve their concurrent programming skills.

The above is the detailed content of Master the Go language synchronization mechanism: improve concurrent programming skills. For more information, please follow other related articles on the PHP Chinese website!