tous les goroutines sont endormis - blocage

Votre monitorWorker ne meurt jamais. Lorsque tous les travailleurs de la finition, il continue à attendre sur les cs. Cette blocages parce que rien d'autre ne sera jamais envoyer de la cs et, par conséquent, wg ne sera jamais atteindre 0. Une solution possible est d'avoir le moniteur fermer le canal lorsque tous les travailleurs de finition. Si la boucle est en principal, ce sera la fin de la boucle, le retour de la principale, et la fin du programme.

Par exemple: http://play.golang.org/p/nai7XtTMfr

package main

import (
    "fmt"
    "strconv"
    "sync"
)

func worker(wg *sync.WaitGroup, cs chan string, i int) {
    defer wg.Done()
    cs <- "worker" + strconv.Itoa(i)
}

func monitorWorker(wg *sync.WaitGroup, cs chan string) {
    wg.Wait()
    close(cs)
}

func main() {
    wg := &sync.WaitGroup{}
    cs := make(chan string)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(wg, cs, i)
    }

    go monitorWorker(wg, cs)

    for i := range cs {
        fmt.Println(i)

    }
}

---

Edit: C'est une réponse à l'OP du premier commentaire.

Votre programme comporte trois parties qui doivent se synchroniser. Tout d'abord, l'ensemble de vos travailleurs ont besoin pour envoyer les données. Ensuite, votre impression de boucle besoin d'imprimer des données. Ensuite, votre principale fonction doit retourner mettant ainsi fin au programme. Dans votre exemple, tous les travailleurs envoyer les données, toutes les données sont imprimées, mais le message n'est jamais envoyé au principal qu'il devrait revenir normalement.

Dans mon exemple, le principal de l'impression et de la "monitorWorker" juste dit principal quand il a reçu chaque morceau de données dont il a besoin pour imprimer. De cette façon, le programme se termine normalement et pas en impasse.

Si vous insistez sur la boucle d'impression d'être dans un autre goroutine, vous pouvez le faire. Mais alors un supplément de communication doit être envoyé aux principaux afin qu'il renvoie. Dans cet exemple, j'utilise un canal pour assurer principale se termine lorsque toutes les données sont imprimées.

package main

import (
    "fmt"
    "strconv"
    "sync"
)

func worker(wg *sync.WaitGroup, cs chan string, i int) {
    defer wg.Done()
    cs <- "worker" + strconv.Itoa(i)
}

func monitorWorker(wg *sync.WaitGroup, cs chan string) {
    wg.Wait()
    close(cs)
}

func printWorker(cs <-chan string, done chan<- bool) {
    for i := range cs {
        fmt.Println(i)
    }

    done <- true
}

func main() {
    wg := &sync.WaitGroup{}
    cs := make(chan string)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(wg, cs, i)
    }

    go monitorWorker(wg, cs)

    done := make(chan bool, 1)
    go printWorker(cs, done)
    <-done
}

OriginalL'auteur Stephen Weinberg