Comment utiliser les primitives de synchronisation pour empêcher la concurrence Goroutine ?

Pour éviter les problèmes de concurrence, des primitives de synchronisation peuvent être utilisées, notamment : Mutex : permet à un seul Goroutine d'accéder aux données partagées à la fois. Sémaphore : limitez le nombre de Goroutines pouvant accéder simultanément aux données partagées. WaitGroup : attendez qu'un groupe de Goroutines termine son exécution. Variable de condition : permet à Goroutine d'attendre que des conditions spécifiques soient remplies. Cas pratique : utilisez Mutex pour empêcher la concurrence et prévenir les problèmes de concurrence des données en coordonnant l'accès de Goroutine aux ressources partagées.

Comment utiliser les primitives de synchronisation pour empêcher la concurrence Goroutine

Dans le langage Go, les Goroutines sont des fonctions concurrentes qui partagent le même espace mémoire. Cela peut entraîner des problèmes de concurrence, tels que des courses aux données, qui se produisent lorsque plusieurs Goroutines accèdent simultanément à des variables partagées.

Pour éviter les problèmes de concurrence, vous pouvez utiliser des primitives de synchronisation, qui sont des techniques utilisées pour coordonner l'accès aux variables partagées.

Primitives de synchronisation communes

Le langage Go fournit plusieurs primitives de synchronisation, notamment :

• Mutex (mutex)  : Il permet à un seul Goroutine d'accéder aux données partagées à la fois.
• Semaphore : Il limite le nombre de Goroutines pouvant accéder aux données partagées en même temps.
• WaitGroup (wait group) : Il est utilisé pour attendre qu'un groupe de Goroutines termine son exécution.
• Condition Variable : Elle permet au Goroutine d'attendre qu'une condition spécifique soit remplie.

Cas pratique : Utiliser Mutex pour empêcher la concurrence

Utilisons un cas pratique pour illustrer comment utiliser Mutex pour empêcher la concurrence. Considérons un scénario dans lequel nous avons une structure Counter qui contient un champ count. Nous souhaitons mettre à jour ce compteur simultanément à l'aide de Goroutines simultanées. Counter 结构，其中包含一个 count 字段。我们希望使用并发 Goroutine 并发更新该计数器。

package main

import (
    "fmt"
    "sync"
)

// Counter represents a simple counter.
type Counter struct {
    mu     sync.Mutex
    count  int
}

// Increment increments the count by 1.
func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

// GetCount returns the current value of the count.
func (c *Counter) GetCount() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

func main() {
    // Create a new counter.
    c := &Counter{}

    // Create a group of Goroutines to increment the counter concurrently.
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            c.Increment()
        }()
    }

    // Wait for all Goroutines to finish.
    wg.Wait()

    // Print the final count.
    fmt.Println("Final count:", c.GetCount())
}

在这个案例中，Mutex 用于保护对 count 字段的访问。当一个 Goroutine 尝试更新计数器时，它会先获取 Mutexrrreee

Dans ce cas, Mutex est utilisé pour protéger l'accès au champ count. Lorsqu'un Goroutine tente de mettre à jour un compteur, il acquiert d'abord le verrou Mutex. Cela empêchera d'autres Goroutines de mettre à jour le compteur en même temps, évitant ainsi les courses aux données.

L'exécution de ce programme imprime le décompte final, qui est la somme de tous les incréments de Goroutine. Cela montre que Mutex a réussi à éviter les problèmes de concurrence. 🎜

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!