Explication détaillée de l'utilisation et exemples de Go WaitGroup

Le langage Go est un langage de programmation dont le noyau est la programmation simultanée et qui est très efficace pour gérer des tâches simultanées. Dans la bibliothèque standard du langage Go, il existe un outil de concurrence très utile, WaitGroup. Cet article présentera l'utilisation de WaitGroup en détail et démontrera son application spécifique à travers des exemples.

Tout d'abord, nous devons comprendre le rôle de WaitGroup. WaitGroup est utilisé pour attendre la fin d'un groupe de tâches simultanées avant de continuer à exécuter le code suivant. Normalement, nous pouvons utiliser WaitGroup lorsque la coroutine principale doit attendre que d'autres coroutines terminent une tâche avant de poursuivre l'exécution.

Sous le package sync du langage Go, il existe une structure WaitGroup, qui comporte trois méthodes principales, à savoir Add(), Done() et Wait(). Ci-dessous, nous présentons leurs fonctions une par une.

La première est la méthode Add(), qui permet d'augmenter le nombre de tâches en attente. Nous pouvons indiquer au WaitGroup combien de tâches nous devons attendre pour être terminées en appelant la méthode Add(). La méthode d'appel spécifique est wg.Add(n), où n représente le nombre de tâches à attendre. Par exemple, si nous avons 10 tâches en attente d’être terminées, nous pouvons appeler wg.Add(10).

Ensuite, il y a la méthode Done(), qui est utilisée pour marquer que la tâche en cours est terminée. Lorsque chaque tâche est terminée, la méthode Done() doit être appelée pour indiquer au WaitGroup que la tâche en cours est terminée. La méthode d'appel spécifique est wg.Done(). Normalement, nous appellerons la méthode Done() dans l'instruction defer une fois la tâche terminée pour garantir que la méthode Done() sera appelée une fois la tâche terminée.

Enfin, il y a la méthode Wait(), qui est utilisée pour bloquer la coroutine principale jusqu'à ce que toutes les tâches soient terminées. Lorsque la coroutine principale doit attendre qu'un ensemble de tâches soit terminée avant de continuer à exécuter le code suivant, la méthode Wait() peut être appelée. La méthode d'appel spécifique est wg.Wait(). La méthode Wait() se bloquera jusqu'à ce que toutes les tâches soient terminées.

Ci-dessous, nous utilisons un exemple pour démontrer l'application spécifique de WaitGroup. Supposons que nous ayons une liste de tâches que nous devons traiter simultanément. Une fois chaque tâche terminée, nous écrivons les résultats dans une liste de résultats. Enfin, nous devons attendre que toutes les tâches soient terminées avant d'imprimer la liste des résultats. Le code est le suivant :

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    taskList := []string{"task1", "task2", "task3", "task4"}

    // 创建结果列表
    resultList := make([]string, len(taskList))

    // 遍历任务列表，开启多个协程处理任务
    for i, task := range taskList {
        wg.Add(1) // 增加等待的任务数

        go func(index int, task string) {
            defer wg.Done() // 标志任务已经完成

            // 模拟任务处理过程
            result := fmt.Sprintf("task %s processed", task)

            // 将结果写入结果列表
            resultList[index] = result
        }(i, task)
    }

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

    // 打印结果列表
    for _, result := range resultList {
        fmt.Println(result)
    }
}

Dans le code ci-dessus, nous créons d'abord un objet WaitGroup wg. Ensuite, nous parcourons la liste des tâches et appelons wg.Add(1) une fois pour chaque tâche, indiquant qu'il y a une tâche à attendre. Dans la fonction de gestionnaire de chaque tâche, nous appelons wg.Done() une fois la tâche terminée. Enfin, nous avons appelé wg.Wait() dans la coroutine principale pour attendre que toutes les tâches soient terminées.

Grâce à cette conception, nous pouvons traiter les tâches simultanément et garantir qu'une fois toutes les tâches terminées, nous pouvons continuer l'exécution ultérieure de la coroutine principale. Enfin, nous avons imprimé la liste des résultats pour vérifier le traitement simultané des tâches et l'exactitude des résultats.

En résumé, WaitGroup est un outil de concurrence très pratique dans le langage Go. En utilisant correctement WaitGroup, nous pouvons mieux gérer les tâches simultanées et garantir l'ordre et l'exactitude des tâches. J'espère que cet article pourra aider les lecteurs à mieux comprendre et appliquer WaitGroup.

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!