Analysez le piège WaitGroup de Golang et résolvez le problème

Cet article vous est présenté par la rubrique go language tutoriel sur le piège WaitGroup de Golang. J'espère qu'il sera utile aux amis dans le besoin !

Le piège WaitGroup de Golang

sync.WaitGroup est une structure de données très courante dans un environnement concurrent, utilisée pour attendre la fin de toutes les coroutines. Lors de l'écriture du code, appuyez sur C'est écrit comme. un exemple, et il n'est pas nécessaire d'approfondir son utilisation. Il y a quelques jours, je me demandais si je pouvais exécuter la fonction Add() dans une coroutine. La réponse est non. Voici une introduction. sync.WaitGroup是并发环境中，一个相当常用的数据结构，用来等待所有协程的结束，在写代码的时候都是按着例子的样子写的，也没用深究过它的使用。前几日想着能不能在协程中执行Add()函数，答案是不能，这里介绍下。

陷阱在WaitGroup的3个函数的调用顺序上。先回顾下3个函数的功能：

1. Add(delta int)：给计数器增加delta，比如启动1个协程就增加1。
2. Done()：协程退出前执行，把计数器减1。
3. Wait()：阻塞等待计数器为0。

考一考

下面的程序是创建了协程father，然后father协程创建了10个子协程，main函数等待所有协程结束后退出，看看下面代码有没有什么问题？

package main

import (
    "fmt"
    "sync"
)

func father(wg *sync.WaitGroup) {
    wg.Add(1)
    defer wg.Done()

    fmt.Printf("father\n")
    for i := 0; i < 10; i++ {
        go child(wg, i)
    }
}

func child(wg *sync.WaitGroup, id int) {
    wg.Add(1)
    defer wg.Done()

    fmt.Printf("child [%d]\n", id)
}

func main() {
    var wg sync.WaitGroup
    go father(&wg)

    wg.Wait()
    log.Printf("main: father and all chindren exit")
}

发现问题了吗？如果没有看下面的运行结果：main函数在子协程结束前就开始结束了。

father
main: father and all chindren exit
child [9]
child [0]
child [4]
child [7]
child [8]

陷阱分析

产生以上问题的原因在于，创建协程后在协程内才执行Add()函数，而此时Wait()函数可能已经在执行，甚至Wait()函数在所有Add()执行前就执行了，Wait()

Le piège réside dans la séquence d'appel des trois fonctions de WaitGroup. Passons d'abord en revue les fonctions des trois fonctions :

1. Add(delta int) : ajoutez du delta au compteur, par exemple, lors du démarrage d'une coroutine, augmentez-le de 1.
2. Done() : exécuté avant la sortie de la coroutine, décrémentant le compteur de 1.
3. Wait() : Le compteur d'attente bloquante est 0.

Faites un test

Le programme suivant crée la coroutine père, puis la coroutine père crée 10 sous-coroutines. La fonction principale attend que toutes les coroutines se terminent, puis se termine. ci-dessous. Pas de problème ?

package main

import (
    "fmt"
    "sync"
)

func father(wg *sync.WaitGroup) {
    defer wg.Done()

    fmt.Printf("father\n")
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go child(wg, i)
    }
}

func child(wg *sync.WaitGroup, id int) {
    defer wg.Done()
    fmt.Printf("child [%d]\n", id)
}

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go father(&wg)

    wg.Wait()
    fmt.Println("main: father and all chindren exit")
}

Avez-vous trouvé le problème ? Si vous ne voyez pas les résultats d'exécution suivants : la fonction principale commence à se terminer avant la fin de la sous-coroutine.

father
child [9]
child [7]
child [8]
child [1]
child [4]
child [5]
child [2]
child [6]
child [0]
child [3]
main: father and all chindren exit

Trap Analysis

La raison du problème ci-dessus est que la fonction Add() est exécutée dans la coroutine après la création de la coroutine, et à ce moment le Wait() <p>Peut-être</p> est déjà en cours d'exécution, ou même la fonction <code>Wait() est exécutée avant que tous les Add() ne soient exécutés, et immédiatement lorsque Wait () est exécuté. Il est satisfait que le compteur de WaitGroup est 0, l'attente se termine et le programme principal se termine. Par conséquent, toutes les sous-coroutines ne sont pas complètement terminées et la fonction principale se termine.

🎜La bonne approche🎜🎜🎜La fonction Add doit être exécutée avant que la fonction Wait soit exécutée🎜 Ceci est suggéré dans la documentation de la fonction Add : 🎜Notez que les appels avec un delta positif qui se produisent lorsque le compteur est nul doivent avoir lieu. avant une attente.🎜. 🎜🎜Comment s'assurer que la fonction Add doit être exécutée avant la fonction Wait ? Dans le cas des coroutines, nous ne pouvons pas prédire si le temps d'exécution du code dans la coroutine est antérieur au temps d'exécution de la fonction Wait. Cependant, nous pouvons nous en assurer en exécutant la fonction Add avant d'attribuer la coroutine, puis en exécutant la coroutine. Fonction d'attente. 🎜🎜Ce qui suit est le programme modifié et les résultats de sortie. 🎜rrreeerrree🎜

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!