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

En attente d'un canal tampon vide (sémaphore)

En programmation simultanée, il est crucial de contrôler le nombre de goroutines qui s'exécutent simultanément. Une approche consiste à utiliser un canal tamponné comme sémaphore. Cependant, un problème courant survient lorsque l'on attend que le sémaphore se vide complètement.

Problème :

Disons que nous avons une tranche d'entiers que nous voulons traiter simultanément, avec une limite de deux simultanés. allez aux routines. Nous utilisons un canal tamponné comme sémaphore pour faire respecter cette limite. Bien que le code fonctionne pour la plupart des nombres entiers, le programme se termine prématurément avant la fin des routines de dernier passage car le tampon n'atteint jamais le vide.

La question :

Comment pouvons-nous attendre que le canal tamponné se vider complètement, en s'assurant que toutes les routines Go sont terminées avant la fin du programme ?

Réponse :

Utiliser un canal pour attendre pour une condition spécifique n'est pas réalisable en raison de l'absence d'un moyen sans course pour vérifier sa longueur. Au lieu de cela, nous pouvons utiliser un sync.WaitGroup pour surveiller l'achèvement de toutes les goroutines.

Code résolu :

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()

En utilisant sync.WaitGroup, nous pouvons attendre que toutes les goroutines se terminent avant le programme se termine, garantissant que tous les traitements sont terminés.

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!