Golang Concurrency Issue to introduce timeout

This kind of fork-and-join pattern is exactly what golang.org/x/sync/errgroup was designed for. (Identifying the appropriate “first error” from a group of goroutines can be surprisingly subtle.)

You can use errgroup.WithContext to obtain a context.Context that is cancelled if any of the goroutines in the group returns. The (*Group).Wait method waits for the goroutines to complete and returns the first error.

For your example, that might look something like: https://play.golang.org/p/jqYeb4chHCZ.

You can then inject a timeout within any given call by wrapping the Context using context.WithTimeout.

(However, in my experience if you've plumbed in cancellation correctly, explicit timeouts are almost never helpful — the end user can cancel explicitly if they get tired of waiting, and you probably don't want to promote degraded service to a complete outage if something starts to take just a bit longer than you expected.)

To support timeouts and cancelation of goroutine work, the standard mechanism is to use context.Context.

ctx := context.Background() // root context

// wrap the context with a timeout and/or cancelation mechanism

ctx, cancel := context.WithTimeout(ctx, 5*time.Second) // with timeout or cancel
//ctx, cancel := context.WithCancel(ctx)               // no   timeout just cancel

defer cancel() // avoid memory leak if we never cancel/timeout

Next your worker goroutines need to support taking and monitoring the state of the ctx. To do this in parallel with the time.Sleep (to mimic a long computation), convert the sleep to a channel based solution:

// mimic api call 1
func doSomeWork(ctx context.Context) (function1, error) {
    //time.Sleep(10 * time.Second)
    select {
    case <-time.After(10 * time.Second):
        // wait completed
    case <-ctx.Done():
        return function1{}, ctx.Err()
    }
    // ...
}

And if one worker goroutine fails, to signal to the other worker that the request should be aborted, simply call the cancel() function.

result, e := doSomeWork(ctx)
if e != nil {
    cancel()    // <- add this
    err <- e
    return
}

Pulling this all together:

https://play.golang.org/p/1Kpe_tre7XI

EDIT: the sleep example above is obviously a contrived example of how to abort a "fake" task. In the real world, http or SQL DB calls would be involve - and since go 1.7 & 1.8 - the standard library added context support to any of these potentially blocking calls:

func doSomeWork(ctx context.Context) (error) 

    // DB

    db, err := sql.Open("mysql", "...") // check err

    //rows, err := db.Query("SELECT age from users", age)
    rows, err := db.QueryContext(ctx, "SELECT age from users", age)
    if err != nil {
        return err // will return with error if context is canceled
    }

    // http

    // req, err := http.NewRequest("GET", "http://example.com", nil)
    req, err := http.NewRequestWithContext(ctx, "GET", "http://example.com", nil) // check err

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return err // will return with error if context is canceled
    }

}

EDIT (2): to poll a context's state without blocking, leverage select's default branch:

 select {
 case <-ctx.Done():
     return ctx.Err()
 default:
     // if ctx is not done - this branch is used
 }

the default branch can optional have code in it, but even if it is empty of code it's presence will prevent blocking - and thus just poll the status of the context in that instant of time.