How to wait for first finished goroutine

Question

I have two algorithm for same task, one is best for some cases and one for some other cases.

So I would like to start two goroutines at the same time whenever processing the task, and only use the result returned by the first finished goroutine.

Also, in the result, I need to know it is returned by which algorithm. And if I think the first returned result is not right, I would like to wait for the second result.

I read thru the doc of https://golang.org/pkg/sync/, seems it can only wait for all goroutine finish.

How can I implement this idea in golang?

Have them all write their results to the same channel with one routine reading results. They'll come in in the order they're sent on the channel. — Adrian, Aug 09 '18 at 13:29
I would recommend that article https://blog.golang.org/pipelines. I think there is everything inside you will need. — apxp, Aug 09 '18 at 13:34

trey-jones · Accepted Answer · 2018-08-09T14:41:03.903

I don't think you need to use sync, though I'm sure you could come up with a solution that does. I think the simplest solution is to:

Create a new channel for each piece of data. I'm not sure of the performance impact of this, so you might do some checking on that.
Send the same output channel to both algorithms.
Take the first value that comes off the channel and see if you like it.
If you don't, take the second value.
Continue without worrying about the open channel. We have garbage collection in go.

Something like this:

type Result struct {
    Value     string
    Algorithm string
}

func (r *Result) String() string {
    return r.Value
}

func A(in string, out chan *Result) {
    out <- &Result{"A", "A"}
}

func B(in string, out chan *Result) {
    out <- &Result{"B", "B"}
}

func main() {
    data := []string{"foo", "bar", "baz"}

    for _, datum := range data {
        resultChan := make(chan *Result, 2)
        expectedResult := "B"

        go A(datum, resultChan)
        go B(datum, resultChan)

        result := <-resultChan
        if result.Value != expectedResult {
            fmt.Println("Unexpected result: ", result)
            result = <-resultChan
        }

        fmt.Println("Got result: ", result)
    }
}

Buffer the channel or use select statements with default clause in A and B. Otherwise one of them will block forever if the first value is deemed good. — Peter, Aug 09 '18 at 14:32

score -1 · Answer 2 · answered Aug 14 '18 at 04:54

You could use Buffer Channel to achieve that, simple code is:

package main

import (
    "fmt"
)
type Result struct {
    Value     string
    Algorithm string
}

func DoTaskA(out chan *Result) {
    out <- &Result{"A", "A"}
}

func DoTaskB(out chan *Result) {
    out <- &Result{"B", "B"}
}

func IsGood(re *Result) bool {
    return re.Value == "B"
}

func main() {
    out := make(chan *Result, 1)
    go DoTaskA(out)
    go DoTaskB(out)
    for {
        re := <- out
        if IsGood(re) {
            fmt.Println("The chosen one is:", re.Algorithm)
            return
        }
    }
}

How to wait for first finished goroutine

2 Answers2