Como esperar que todas as goroutines terminem sem usar o tempo. Sono?

Este código seleciona todos os arquivos xml na mesma pasta, como o executável invocado e aplica de forma assíncrona o processamento a cada resultado no método de retorno de chamada (no exemplo abaixo, apenas o nome do arquivo é impresso).

Como evito usar o método sleep para impedir que o método principal saia? Tenho problemas para entender os canais (presumo que seja o que for preciso, para sincronizar os resultados), então qualquer ajuda é apreciada!

package main

import (
    "fmt"
    "io/ioutil"
    "path"
    "path/filepath"
    "os"
    "runtime"
    "time"
)

func eachFile(extension string, callback func(file string)) {
    exeDir := filepath.Dir(os.Args[0])
    files, _ := ioutil.ReadDir(exeDir)
    for _, f := range files {
            fileName := f.Name()
            if extension == path.Ext(fileName) {
                go callback(fileName)
            }
    }
}


func main() {
    maxProcs := runtime.NumCPU()
    runtime.GOMAXPROCS(maxProcs)

    eachFile(".xml", func(fileName string) {
                // Custom logic goes in here
                fmt.Println(fileName)
            })

    // This is what i want to get rid of
    time.Sleep(100 * time.Millisecond)
}

Você pode usar sync.WaitGroup . Citando o exemplo vinculado:

package main

import (
        "net/http"
        "sync"
)

func main() {
        var wg sync.WaitGroup
        var urls = []string{
                "http://www.golang.org/",
                "http://www.google.com/",
                "http://www.somestupidname.com/",
        }
        for _, url := range urls {
                // Increment the WaitGroup counter.
                wg.Add(1)
                // Launch a goroutine to fetch the URL.
                go func(url string) {
                        // Decrement the counter when the goroutine completes.
                        defer wg.Done()
                        // Fetch the URL.
                        http.Get(url)
                }(url)
        }
        // Wait for all HTTP fetches to complete.
        wg.Wait()
}

WaitGroups são definitivamente a maneira canônica de fazer isso. No entanto, apenas por uma questão de integridade, aqui está a solução que era comumente usada antes da introdução dos WaitGroups. A ideia básica é usar um canal para dizer "terminei" e fazer a goroutine principal esperar até que cada rotina gerada tenha relatado sua conclusão.

func main() {
    c := make(chan struct{}) // We don't need any data to be passed, so use an empty struct
    for i := 0; i < 100; i++ {
        go func() {
            doSomething()
            c <- struct{}{} // signal that the routine has completed
        }()
    }

    // Since we spawned 100 routines, receive 100 messages.
    for i := 0; i < 100; i++ {
        <- c
    }
}

sync.WaitGroup pode ajudá-lo aqui.

package main

import (
    "fmt"
    "sync"
    "time"
)


func wait(seconds int, wg * sync.WaitGroup) {
    defer wg.Done()

    time.Sleep(time.Duration(seconds) * time.Second)
    fmt.Println("Slept ", seconds, " seconds ..")
}


func main() {
    var wg sync.WaitGroup

    for i := 0; i <= 5; i++ {
        wg.Add(1)   
        go wait(i, &wg)
    }
    wg.Wait()
}

Embora sync.waitGroup(wg) seja a maneira canônica de avançar, ele exige que você faça pelo menos algumas de suas wg.Addchamadas antes wg.Waitde todas serem concluídas. Isso pode não ser viável para coisas simples como um rastreador da web, onde você não sabe o número de chamadas recursivas de antemão e leva um tempo para recuperar os dados que conduzem owg.Add chamadas. Afinal, você precisa carregar e analisar a primeira página antes de saber o tamanho do primeiro lote de páginas filhas.

Eu escrevi uma solução usando canais, evitando waitGroupem minha solução o exercício Tour of Go - web crawler . Cada vez que uma ou mais rotinas de go são iniciadas, você envia o número para o childrencanal. Cada vez que uma rotina go está prestes a ser concluída, você envia um 1para o donecanal. Quando a soma dos filhos for igual à soma de done, estamos prontos.

Minha única preocupação restante é o tamanho do resultscanal embutido, mas essa é uma limitação do Go (atual).

// recursionController is a data structure with three channels to control our Crawl recursion.
// Tried to use sync.waitGroup in a previous version, but I was unhappy with the mandatory sleep.
// The idea is to have three channels, counting the outstanding calls (children), completed calls 
// (done) and results (results).  Once outstanding calls == completed calls we are done (if you are
// sufficiently careful to signal any new children before closing your current one, as you may be the last one).
//
type recursionController struct {
    results  chan string
    children chan int
    done     chan int
}

// instead of instantiating one instance, as we did above, use a more idiomatic Go solution
func NewRecursionController() recursionController {
    // we buffer results to 1000, so we cannot crawl more pages than that.  
    return recursionController{make(chan string, 1000), make(chan int), make(chan int)}
}

// recursionController.Add: convenience function to add children to controller (similar to waitGroup)
func (rc recursionController) Add(children int) {
    rc.children <- children
}

// recursionController.Done: convenience function to remove a child from controller (similar to waitGroup)
func (rc recursionController) Done() {
    rc.done <- 1
}

// recursionController.Wait will wait until all children are done
func (rc recursionController) Wait() {
    fmt.Println("Controller waiting...")
    var children, done int
    for {
        select {
        case childrenDelta := <-rc.children:
            children += childrenDelta
            // fmt.Printf("children found %v total %v\n", childrenDelta, children)
        case <-rc.done:
            done += 1
            // fmt.Println("done found", done)
        default:
            if done > 0 && children == done {
                fmt.Printf("Controller exiting, done = %v, children =  %v\n", done, children)
                close(rc.results)
                return
            }
        }
    }
}

Código-fonte completo para a solução

Aqui está uma solução que emprega WaitGroup.

Primeiro, defina 2 métodos de utilidade:

package util

import (
    "sync"
)

var allNodesWaitGroup sync.WaitGroup

func GoNode(f func()) {
    allNodesWaitGroup.Add(1)
    go func() {
        defer allNodesWaitGroup.Done()
        f()
    }()
}

func WaitForAllNodes() {
    allNodesWaitGroup.Wait()
}

Em seguida, substitua a invocação de callback:

go callback(fileName)

Com uma chamada para sua função de utilidade:

util.GoNode(func() { callback(fileName) })

Última etapa, adicione esta linha no final de seu main, em vez de seu sleep. Isso garantirá que o thread principal esteja aguardando que todas as rotinas sejam concluídas antes que o programa possa ser interrompido.

func main() {
  // ...
  util.WaitForAllNodes()
}