一个完成后如何完成所有goroutine

Question

I want to run multiple goroutines, make some processing, put a result into channel, and when there's at least one goroutine finished, finish all others and return result from channel.

So, I tried to implement this using wait group, but seems I haven't use wait group properly.

    package optimizer

    import (
        "github.com/tevino/abool"
        "errors"
        "sync"
        "runtime"
        "log"
    )

    type Optimizer struct {
        Handlers      []ofdHandler.Handler
    }

    func Make(handlers []ofdHandler.Handler, maxProcs int) Optimizer {
        runtime.GOMAXPROCS(maxProcs)
        return Optimizer{Handlers: handlers}
    }

    func (o Optimizer) Optimize(params operations.GetV1ReceiptsParams) (*models.Receipt, error) {
        var wg sync.WaitGroup
        wg.Add(len(o.Handlers))

        results := make(chan *models.Receipt)
        isCalculated := abool.NewBool(false)

        for _, handler := range o.Handlers {
            go func(handler ofdHandler.Handler) {
                log.Println("Starting handler: ", handler.GetName())
                defer wg.Done()

                if isCalculated.IsSet() {
                    log.Println("Result is calculated, exiting goroutine...")
                    return
                }

                receipt, err := handler.Handle(params)
                if err != nil {
                    log.Println(err)
                    return
                }

                if isCalculated.IsSet() {
                    log.Println("Result is calculated, exiting goroutine...")
                    return
                }

                log.Println("Writing result to channel...")
                isCalculated.Set()
                results <- receipt
            }(handler)
        }

        log.Println("Waiting...")
        wg.Wait()

        if receipt, ok := <-results; ok {
            return receipt, nil
        }

        return nil, errors.New("couldn't optimize with current list of Handlers")
    }

Answer 1

The code you posted is not compilable as is and you don't describe the problem (what happens instead of expected result) either, but by looking at the code I have two suggestions:

Make the result channel buffered, length 1:

results := make(chan *models.Receipt, 1)

This allows the goroutine which finishes first to write the result into the cannel and exit, thus decrementing the waitgroup's counter.

In the end, instead of isCalculated.Set() you should use SetToIf so that you wouldn't set the flag/result twice (and thus stalling, as the reader is still waiting for the waitgroup to "complete" and so the second goroutine wouldn't be able to write into the channel, which means that the waitgroup never reaches to zero):

log.Println("Writing result to channel...")
if isCalculated.SetToIf(false, true) {
   results <- receipt
}