Décryptage : Stratégie d'attente de la fonction principale en langage Go

Déchiffrement : La stratégie d'attente de la fonction principale en langage Go nécessite des exemples de code spécifiques

Le langage Go est un langage de programmation concurrent, et la stratégie d'attente de la fonction principale est particulièrement importante. La fonction principale doit s'assurer qu'elle se termine une fois que toutes les goroutines ont été exécutées, sinon le programme pourrait se terminer prématurément. Cet article présentera plusieurs stratégies courantes d’attente des fonctions principales et fournira des exemples de code spécifiques.

Dans le langage Go, WaitGroup ou canal dans le package de synchronisation est généralement utilisé pour implémenter l'attente dans la fonction principale. Ci-dessous, nous présenterons respectivement les applications spécifiques de ces deux méthodes.

1. Utilisez WaitGroup dans le package de synchronisation

WaitGroup est un mécanisme de synchronisation qui peut être utilisé pour attendre la fin d'un groupe de goroutines. La méthode Add est principalement utilisée pour augmenter le nombre de goroutines en attente, la méthode Done est utilisée pour réduire le nombre et la méthode Wait attend que toutes les goroutines soient exécutées. Voici un exemple de code :

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d is working
", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
    fmt.Println("All workers have finished")
}

Dans le code ci-dessus, nous définissons une fonction de travail pour simuler une goroutine qui doit être exécutée, puis démarrons 3 goroutines de travail dans la fonction principale et attendons qu'elles terminent leur exécution via l'attente méthode.

2. Utiliser les canaux

Une autre stratégie d'attente de fonction principale courante consiste à utiliser les canaux. Nous pouvons créer un canal et laisser chaque goroutine envoyer un signal à ce canal à la fin. La fonction principale peut recevoir ce signal pour déterminer si toutes les goroutines ont été exécutées. Voici un exemple de code :

package main

import "fmt"

func worker(id int, ch chan bool) {
    fmt.Printf("Worker %d is working
", id)
    ch <- true
}

func main() {
    numWorkers := 3
    ch := make(chan bool, numWorkers)

    for i := 1; i <= numWorkers; i++ {
        go worker(i, ch)
    }

    for i := 1; i <= numWorkers; i++ {
        <-ch
    }

    fmt.Println("All workers have finished")
}

Dans cet exemple, nous créons un canal avec une capacité de numWorkers et laissons chaque goroutine de travailleur envoyer une valeur à ce canal à la fin. La fonction principale reçoit ces valeurs pour déterminer si toutes les goroutines ont été exécutées.

Résumé

Grâce aux deux exemples de code spécifiques ci-dessus, nous avons découvert deux manières courantes d'implémenter la stratégie d'attente de la fonction principale dans le langage Go : en utilisant WaitGroup dans le package de synchronisation et en utilisant des canaux. Dans le développement réel, il est très important de choisir une stratégie d'attente appropriée en fonction de la situation spécifique, afin de garantir que le programme peut attendre correctement que toutes les goroutines terminent leur exécution avant de se terminer pendant une exécution simultanée.

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!