Contrôle de concurrence dans Golang et Go WaitGroup

Contrôle de concurrence et Go WaitGroup dans Golang

Dans Golang, nous pouvons utiliser goroutine pour implémenter des tâches d'exécution simultanées. Cependant, dans certains cas, nous devons contrôler le nombre d’exécutions simultanées pour éviter une consommation excessive de ressources ou des problèmes de concurrence. Golang fournit certaines méthodes pour réaliser le contrôle de concurrence, dont la plus couramment utilisée consiste à utiliser Go WaitGroup.

Go WaitGroup est un sémaphore de comptage utilisé pour attendre qu'un groupe de goroutines termine son exécution. Lorsque nous démarrons un groupe de goroutines, nous pouvons utiliser WaitGroup pour suivre l'état de ces goroutines et effectuer l'étape suivante une fois toutes les goroutines terminées.

Ci-dessous, nous utilisons un exemple de code spécifique pour démontrer le contrôle de concurrence dans Golang et l'utilisation de Go WaitGroup.

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    numWorkers := 5
    var wg sync.WaitGroup

    for i := 0; i < numWorkers; i++ {
        wg.Add(1) // 每启动一个goroutine，等待组加1
        go worker(i, &wg)
    }

    wg.Wait() // 等待所有goroutine完成

    fmt.Println("All workers have finished")
}

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // goroutine执行完毕，等待组减1
    
    fmt.Printf("Worker %d started
", id)
    time.Sleep(time.Second) // 模拟耗时操作
    fmt.Printf("Worker %d finished
", id)
}

Dans cet exemple, nous avons 5 goroutines, et la tâche de chaque exécution est d'appeler la fonction de travail. Tout d’abord, nous avons défini une variable WaitGroup wg et démarré 5 goroutines dans la fonction principale. Chaque goroutine appelle la fonction de travail et exploite le WaitGroup en passant un pointeur vers wg.

Dans la fonction Worker, nous utilisons defer wg.Done() pour réduire le nombre de groupes en attente une fois l'exécution de la goroutine terminée. Cela signifie que chaque goroutine appellera la fonction Done() pour avertir le WaitGroup lorsqu'elle sera terminée. Ensuite, nous avons ajouté des opérations chronophages simulées à chaque fonction de travail pour observer l'effet de l'exécution simultanée.

Dans la fonction principale, nous appelons wg.Wait() pour attendre que toutes les goroutines soient terminées. Cela entraînera le blocage de la fonction principale une fois que toutes les goroutines auront fini de s'exécuter, jusqu'à ce que le nombre WaitGroup atteigne zéro.

Exécutez le code ci-dessus, vous verrez un résultat similaire à celui-ci :

Worker 0 started
Worker 1 started
Worker 2 started
Worker 3 started
Worker 4 started
Worker 3 finished
Worker 2 finished
Worker 0 finished
Worker 1 finished
Worker 4 finished
All workers have finished

Comme le montre le résultat, toutes les goroutines démarrent et s'exécutent de manière simultanée, et notifient la fonction principale une fois terminées.

En utilisant Go WaitGroup, nous pouvons facilement contrôler le nombre d'exécutions simultanées et effectuer des opérations ultérieures une fois toutes les goroutines terminées. Ceci est très utile pour gérer des tâches simultanées à grande échelle ou limiter la consommation de ressources.

Pour résumer, le contrôle de concurrence et Go WaitGroup dans Golang sont des outils importants pour la mise en œuvre de la programmation simultanée. Nous pouvons utiliser WaitGroup pour suivre et contrôler l'exécution d'un groupe de goroutines afin de garantir l'exactitude et la stabilité des opérations simultanées. De cette façon, nous pouvons mieux utiliser les processeurs et les ressources multicœurs et améliorer l’efficacité de l’exécution des programmes.

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!