Comment la fonction golang attend-elle que goroutine se termine via WaitGroup ?

WaitGroup est un mécanisme de synchronisation dans Go pour coordonner l'exécution des goroutines. Utilisez ceci pour vous assurer que le goroutine principal attend la fin d'un groupe de goroutines avant de poursuivre l'exécution. Utilisation spécifique : créez une instance WaitGroup et définissez un compteur initial pour celle-ci, indiquant le nombre de goroutines à attendre. Pour chaque goroutine à attendre, appelez wg.Add(1) pour incrémenter le compteur. Une fois la goroutine terminée, appelez wg.Done() pour décrémenter le compteur. Enfin, la goroutine principale appelle wg.Wait() pour se bloquer jusqu'à ce que toutes les goroutines soient terminées.

Comment utiliser WaitGroup pour attendre la fin de Goroutine dans Go

WaitGroup dans Go est un mécanisme de synchronisation utilisé pour coordonner l'exécution de plusieurs goroutines. Il permet au goroutine principal d'attendre la fin d'un groupe de goroutines, garantissant ainsi que toutes les tâches associées sont terminées avant de poursuivre l'exécution. WaitGroup 是一种同步机制，用于协调多个 goroutine 的执行。它允许主 goroutine 等待一组 goroutine 完成，从而确保在继续执行之前所有相关任务都已完成。

用法：

创建一个 WaitGroup 实例，并为其设置一个初始计数器，表示要等待的 goroutine 数。对于每个要等待的 goroutine，调用 wg.Add(1) 来增加计数器，并在 goroutine 完成后调用 wg.Done() 来减少计数器。最后，主 goroutine 调用 wg.Wait() 来阻塞自身，直到所有 goroutine 都已完成。

代码示例：

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup

func main() {
    // 创建一个需要等待 3 个 goroutine 完成的 WaitGroup
    wg.Add(3)

    // 创建 3 个 goroutine
    for i := 0; i < 3; i++ {
        go func(i int) {
            fmt.Printf("Goroutine %d started\n", i)
            
            // 模拟一些需要时间的工作
            for j := 0; j < 10000; j++ {}
            
            fmt.Printf("Goroutine %d finished\n", i)
            
            // 通知 WaitGroup 该 goroutine 已完成
            wg.Done()
        }(i)
    }

    // 等待所有 goroutine 完成
    wg.Wait()
    fmt.Println("All goroutines have finished")
}

实战案例：

此代码示例模拟了一个简单的 Web 服务器，该服务器会启动多个 goroutine 来处理请求。为了确保在关闭服务器之前 goroutine 已完成，我们使用 WaitGroup

🎜Utilisation : 🎜🎜🎜Créez une instance WaitGroup et définissez un compteur initial pour celle-ci, indiquant le nombre de goroutines à attendre. Pour chaque goroutine à attendre, appelez wg.Add(1) pour incrémenter le compteur, et lorsque la goroutine se termine, appelez wg.Done() pour décrémenter le compteur. Enfin, la goroutine principale appelle wg.Wait() pour se bloquer jusqu'à ce que toutes les goroutines soient terminées. 🎜🎜🎜Exemple de code : 🎜🎜

package main

import (
    "fmt"
    "net/http"
    "sync"
)

var wg sync.WaitGroup

func main() {
    // 创建一个需要等待所有 HTTP 请求完成的 WaitGroup
    wg.Add(10)

    // 监听端口 8080
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!")
        
        // 请求处理完毕后，通知 WaitGroup
        wg.Done()
    })
    http.ListenAndServe(":8080", nil)
    
    // 等待所有 HTTP 请求完成
    wg.Wait()
    fmt.Println("All HTTP requests have been processed")
}

🎜🎜Cas pratique : 🎜🎜🎜Cet exemple de code simule un simple serveur Web qui démarre plusieurs goroutines pour gérer les requêtes. Pour nous assurer que les goroutines sont terminées avant d'arrêter le serveur, nous utilisons WaitGroup pour attendre que toutes les goroutines se terminent. 🎜rrreee

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!