Comment attendre que tous les Goroutines se terminent à Golang à l'aide d'un groupe d'attente?

La méthode principale d'utilisation de Sync.WaitGroup dans Go to Wait To All Goroutines pour terminer les tâches est: 1. Initialisez WaitGroup et appelez Ajouter (1) avant de démarrer chaque goroutine; 2. Utilisez un déferation wg.done () à l'intérieur de chaque goroutine pour vous assurer que le nombre est réduit d'une fois la tâche terminée; 3. La coroutine principale appelle wg.wait () pour bloquer et attendre que toutes les tâches se terminent. Ce mécanisme convient aux scénarios où les tâches sont exécutées simultanément et les résultats sont résumés, tels que le traitement par lots ou les demandes simultanées. Remarque Lorsque l'utilisation: ADD doit être appelée dans la coroutine principale, la réalisation doit être utilisée avec un repère, le groupe d'attente doit être passé dans un pointeur pour éviter les problèmes de blocage causés par la copie des valeurs ou des paniques.

C'est une pratique courante et pratique d'attendre que tous les Goroutines effectuent des tâches en utilisant sync.WaitGroup en Go. Il convient aux scénarios où plusieurs tâches sont exécutées simultanément et attendent qu'elles se terminent, telles que le traitement par lots, les demandes simultanées, etc.

L'idée principale est: enregistrer le nombre de tâches actuellement inachevées à travers le comptoir et informer le groupe Waits pour être réduit d'une fois chaque goroutine terminé, et la coroutine principale continuera de s'exécuter lorsque le nombre reviendra à zéro.

Initialiser et configurer le groupe d'attente

Pour utiliser WaitGroup , vous devez d'abord déclarer une variable et appeler Add(1) pour augmenter le compteur avant de commencer chaque goroutine. Il est généralement fait pour initialiser dans le goroutine principal:

 var wg sync.waitgroup

pour _, élément: = éléments de plage {
    wg.add (1)
    aller func (i élément) {
        différer wg.done ()
        // Exécuter la logique des tâches} (item)
}

Quelques points à noter:

• Add(1) doit être appelé une fois à chaque fois qu'un goroutine est démarré.
• Habituellement utilisé avec defer wg.Done() pour s'assurer que la panique peut être réduite par une même si elle se produit.
• Si vous créez un goroutine dans une boucle, n'oubliez pas de passer les arguments pour éviter les problèmes de fermeture.

Le fil principal attend que toutes les tâches se terminent

Après avoir configuré tous les Goroutines, appelez wg.Wait() dans le thread principal pour bloquer et attendre que toutes les tâches se terminent:

 wg.wait ()
fmt.println ("Tous les Goroutines terminés")

Cette étape est souvent utilisée pour:

• À la fin de la fonction principale, attendez que la tâche d'arrière-plan se termine avant de quitter le programme
• Traitez plusieurs sous-tâches simultanément dans une fonction et résumez les résultats après tout.

Par exemple, vous pouvez lancer plusieurs demandes HTTP en même temps lorsque vous faites des données agrégées, puis attendez que tous reviennent avant de traiter les résultats.

Notes et erreurs communes

Bien que WaitGroup soit simple à utiliser, il y a quelques points sujets aux erreurs:

• Le moment de l'ajout est mauvais : Add ne peut pas être appelé à l'intérieur du goroutine, sinon il peut provoquer une condition de course ou un comptage inexact.
• Terminé ne s'enroule pas avec un report : s'il y a de la panique en goroutine, aucune différence ne peut entraîner la défaillance de l'exécution et d'attendre continuera de bloquer.
• Erreur de méthode de pass de pass WaitGroup : Goroutine doit être transmis en tant que pointeur et ne copiez pas la valeur.

Par exemple, la méthode d'écriture suivante provoquera des blocages:

 // Exemple d'erreur Func Badexample () {
    var wg sync.waitgroup
    aller func () {
        wg.add (1) // pas dans le thread principal ajouter, peut-être que l'attente a été appelée avant l'exécution
        // faire quelque chose
        wg.done ()
    } ()
    wg.wait () // Vous ne pouvez peut-être jamais attendre}

Fondamentalement, c'est tout. En maîtrisant la commande et l'emplacement d' Add , Done et Wait , vous pouvez bien contrôler le processus de concurrence. Ce mécanisme n'est pas compliqué, mais si vous ne faites pas attention, il y aura des problèmes, en particulier dans des environnements simultanés que le débogage n'est pas facile.

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!