Comment s'assurer que tous les Goroutines sont terminés avant la sortie du programme lors de l'utilisation d'un canal tamponné comme sémaphore ?

En attente de drainage d'un canal tamponné

Dans le code fourni, un canal tamponné est utilisé comme sémaphore pour limiter le nombre de canaux simultanément exécuter des goroutines. Cependant, sans mécanisme explicite pour attendre que le canal se vide, le programme principal peut se terminer avant que toutes les goroutines n'aient terminé leur exécution.

Problème :

Comment s'assurer que le programme attend que toutes les goroutines soient terminées avant sortir ?

Réponse :

L'utilisation d'un sémaphore (canal) à cette fin n'est pas idéale car il n'existe aucun moyen intégré pour vérifier la longueur du canal et attendre pour qu'il atteigne 0. Pour attendre correctement la fin des goroutines, pensez à utiliser une primitive de synchronisation comme un sync.WaitGroup.

Code mis à jour :

sem := make(chan struct{}, 2)
var wg sync.WaitGroup

for _, i := range ints {
    wg.Add(1)
    // acquire semaphore
    sem <- struct{}{}
    // start long running go routine
    go func(id int) {
        defer wg.Done()
        // do something
        // release semaphore
        <-sem
    }(i)
}

wg.Wait()

Le sync.WaitGroup maintient un nombre de tâches en attente (goroutines dans ce cas) . Cela permet au programme principal d'attendre que toutes les tâches soient terminées. wg.Add(1) incrémente le nombre de tâches avant de démarrer une nouvelle goroutine, et wg.Done() décrémente le nombre lorsqu'une goroutine se termine. L'appel wg.Wait() bloque le programme principal jusqu'à ce que le nombre de tâches atteigne 0, garantissant que toutes les goroutines sont terminées avant la fin du programme.

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!