Comment utiliser Go WaitGroup pour gérer des tâches simultanées

Comment utiliser Go WaitGroup pour gérer des tâches simultanées

Dans le langage Go, nous pouvons gérer des tâches simultanées en utilisant sync.WaitGroup. sync.WaitGroup peut fournir un moyen concis et efficace de coordonner l'exécution des coroutines lors de la gestion de tâches simultanées. sync.WaitGroup来处理并发任务。sync.WaitGroup可以在处理并发任务时提供一种简洁而有效的方式来协调协程的执行。

sync.WaitGroup是一个有用的工具，在我们不知道有多少个协程需要等待的情况下，是处理并发任务的首选方法。它可以让我们确保在所有任务都完成之前，主协程不会结束执行。

让我们来看一个具体的例子，展示如何使用sync.WaitGroup来处理并发任务。

首先，我们需要导入sync包：

import (
    "fmt"
    "sync"
)

接下来，让我们创建一个sync.WaitGroup对象：

var wg sync.WaitGroup

然后，我们可以通过调用Add方法来添加需要等待的任务数目。在这个例子中，我们将添加两个任务：

wg.Add(2)

接下来，我们可以启动两个协程来执行任务。我们可以将任务封装在一个匿名函数中，然后将其作为参数传递给go关键字。

go func() {
    defer wg.Done()
    // 这里是第一个任务的代码逻辑
}()

go func() {
    defer wg.Done()
    // 这里是第二个任务的代码逻辑
}()

在这个例子中，我们将每个协程内部的defer wg.Done()放在go关键字之后，以确保任务完成之后能够通知WaitGroup对象。

最后，我们可以执行Wait方法来阻塞主协程，直到所有任务都完成。这个方法将等待WaitGroup对象中的任务数目减为零。

wg.Wait()

下面是完整的示例代码：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        defer wg.Done()
        fmt.Println("Task 1 executed")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("Task 2 executed")
    }()

    wg.Wait()
    fmt.Println("All tasks completed")
}

运行这段代码，你会看到输出打印了两个任务的执行结果，然后打印了"所有任务已完成"。

通过使用sync.WaitGroup，我们可以很方便地处理并发任务，确保所有任务都执行完成之后再继续主协程的执行。这对于需要在主协程中等待所有任务完成的情况下特别有用，比如爬虫、并行计算等场景。

总结一下，使用sync.WaitGroup

sync.WaitGroup est un outil utile et constitue la méthode privilégiée pour gérer les tâches simultanées lorsque nous ne savons pas combien de coroutines doivent attendre. Cela nous permet de garantir que la coroutine principale ne termine pas son exécution tant que toutes les tâches ne sont pas terminées.

Regardons un exemple spécifique montrant comment utiliser sync.WaitGroup pour gérer des tâches simultanées. 🎜🎜Tout d'abord, nous devons importer le package sync : 🎜rrreee🎜Ensuite, créons un objet sync.WaitGroup : 🎜rrreee🎜Ensuite, nous pouvons appeler >Add pour ajouter le nombre de tâches à attendre. Dans cet exemple, nous ajouterons deux tâches : 🎜rrreee🎜 Ensuite, nous pouvons démarrer deux coroutines pour effectuer les tâches. Nous pouvons encapsuler la tâche dans une fonction anonyme et la passer en paramètre au mot-clé go. 🎜rrreee🎜Dans cet exemple, nous mettons le defer wg.Done() à l'intérieur de chaque coroutine après le mot-clé go pour nous assurer qu'il peut être notifié une fois la tâche terminée WaitGroup. 🎜🎜Enfin, nous pouvons exécuter la méthode Wait pour bloquer la coroutine principale jusqu'à ce que toutes les tâches soient terminées. Cette méthode réduit à zéro le nombre de tâches dans l'objet WaitGroup en attente. 🎜rrreee🎜Voici l'exemple de code complet : 🎜rrreee🎜Exécutez ce code et vous verrez que la sortie imprime les résultats d'exécution des deux tâches, puis imprime "Toutes les tâches terminées". 🎜🎜En utilisant sync.WaitGroup, nous pouvons facilement gérer les tâches simultanées et nous assurer que toutes les tâches sont terminées avant de poursuivre l'exécution de la coroutine principale. Ceci est particulièrement utile lorsque vous devez attendre que toutes les tâches soient terminées dans la coroutine principale, telles que les robots d'exploration, le calcul parallèle et d'autres scénarios. 🎜🎜Pour résumer, l'utilisation de sync.WaitGroup peut nous aider à gérer des tâches simultanées dans le langage Go. Il fournit un moyen concis et efficace de coordonner l'exécution de la coroutine et de garantir que toutes les tâches sont terminées avant de poursuivre l'exécution de la coroutine principale. J'espère que cet article vous aidera à comprendre le traitement des tâches simultanées. 🎜🎜(Nombre total de mots : 409)🎜

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!