Maîtriser le mécanisme de synchronisation du langage Go : améliorer les compétences en programmation simultanée

En tant que langage de programmation concurrent, le langage Go fournit de riches mécanismes de synchronisation pour aider les développeurs à résoudre les problèmes de concurrence. La maîtrise de ces mécanismes de synchronisation est cruciale pour améliorer vos compétences en programmation simultanée. Cet article illustrera certains mécanismes de synchronisation courants dans le langage Go à travers des exemples de code spécifiques pour aider les lecteurs à mieux comprendre et utiliser ces mécanismes.

1. Mutex (Mutex)

Mutex est un mécanisme de synchronisation de base utilisé pour protéger les ressources partagées contre l'accès par plusieurs goroutines en même temps. Ce qui suit est un exemple simple de verrouillage mutex :

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

Dans l'exemple ci-dessus, le sync.Mutex est utilisé pour protéger la variable counter des accès simultanés, garantissant qu'il y a un seul Goroutine à la fois peut exécuter la fonction incrementCounter(). sync.Mutex来保护counter变量的并发访问，确保每次只有一个goroutine可以执行incrementCounter()函数。

2. 通道（Channel）

通道是Go语言中一种用于在goroutine之间进行通信的机制，它可以用来传递数据和控制并发。下面是一个简单的通道示例：

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

在上面的示例中，通过通道ch在两个goroutine之间传递数据。sendData()函数向通道发送数据，receiveData()函数从通道接收数据，通过range来遍历通道中的数据。

3. 条件变量（Cond）

条件变量是一种在goroutine之间等待或发信号的机制，常用于实现一些复杂的同步逻辑。下面是一个简单的条件变量示例：

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()
}

在上面的示例中，通过条件变量cond和互斥锁mutex来实现两个goroutine之间的同步。worker1()函数等待done变量为true时才继续执行，worker2()函数设置done变量为true并发送信号给worker1()

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!