Comment fermer un canal rempli par plusieurs goroutines lorsque tout le travail est terminé ?

Comment fermer un canal rempli par plusieurs goroutines lorsque tout le travail est terminé est une question souvent posée. En Go, fermer un canal est une manière de notifier au récepteur qu'il n'y a plus de données. En fermant le canal, le destinataire peut savoir à temps que l'expéditeur a terminé toutes les opérations d'envoi. Dans un canal rempli de plusieurs goroutines, nous pouvons utiliser un compteur pour suivre combien de goroutines supplémentaires envoient des données au canal. Lorsque le compteur tombe à 0, tous les travaux sont terminés et nous pouvons fermer le canal en toute sécurité. Après avoir fermé le canal, le récepteur peut déterminer si le canal a été fermé en utilisant des variables supplémentaires dans l'expression de réception. De cette façon, nous pouvons garantir que les canaux remplis par plusieurs goroutines sont correctement fermés une fois tous les travaux terminés, évitant ainsi les fuites de ressources et les problèmes de blocage.

Contenu de la question

J'essaie de suivre la méthode Go consistant à "ne pas communiquer via la mémoire partagée, mais de partager la mémoire via la communication" et d'utiliser des canaux pour communiquer de manière asynchrone les tâches à accomplir et renvoyer les résultats des tâches de traitement.

Pour plus de simplicité, j'ai changé les types de canaux en int au lieu de leurs véritables structures. Et remplacé le long traitement par time.Sleep().

Comment fermer ProducedResults ，以便此代码不会卡在最后一个 for après avoir renvoyé tous les résultats de la tâche ?

quantityOfTasks:= 100
    quantityOfWorkers:= 60
    remainingTasks := make(chan int)
    producedResults := make(chan int)

    // produce tasks
    go func() {
        for i := 0; i < quantityOfTasks; i++ {
            remainingTasks <- 1
        }
        close(remainingTasks)
    }()

    // produce workers
    for i := 0; i < quantityOfWorkers; i++ {
        go func() {
            for taskSize := range remainingTasks {
                // simulate a long task
                time.Sleep(time.Second * time.Duration(taskSize))
                // return the result of the long task
                producedResults <- taskSize
            }
        }()
    }

    // read the results of the tasks and agregate them
    executedTasks := 0
    for resultOfTheTask := range producedResults { //this loop will never finish because producedResults never gets closed
        // consolidate the results of the tasks
        executedTasks += resultOfTheTask
    }

Solution de contournement

Vous souhaitez fermer la chaîne une fois que toutes les goroutines qui y ont écrit sont revenues. Vous pouvez utiliser WaitGroup pour réaliser :

wg:=sync.WaitGroup{}

for i := 0; i < quantityOfWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for taskSize := range remainingTasks {
                //simulate a long task
                time.Sleep(time.Second * time.Duration(taskSize))
                //return the result of the long task
                producedResults <- taskSize
            }
        }()
}

go func() {
  wg.Wait()
  close(producedResults)
}()

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!