How to Implement a Timed Wait for WaitGroup.Wait() in Go?

Timed Wait for WaitGroup.Wait()

In Go, the WaitGroup type is used to synchronize multiple goroutines until all have completed their tasks. The WaitGroup.Wait() method blocks until all members of the group have signaled their completion or the context is canceled.

However, it is sometimes desirable to impose a timeout on the WaitGroup wait operation, to prevent the scheduler from indefinitely waiting for an errant worker. This opens up philosophical questions about the reliability and recoverability of the system in the presence of such errors, but this discussion is beyond the scope of this question.

Solution

The provided solution utilizes a channel and a select statement to achieve the timeout functionality:

c := make(chan struct{})
go func() {
    defer wg.Done()
    // Do the work
    c <- struct{}{}
}()
select {
case <-c:
    // Work completed
case <-time.After(timeout):
    // Timed out
}

This solution is effective, but it may seem overly convoluted. The following tips can improve it:

• Consider using channel closure to signal completion instead of sending a value on the channel. Reading from a closed channel always proceeds immediately.
• Use the defer statement to signal completion. It executes even if a function terminates abruptly.
• If there is only one job to wait for, omit the WaitGroup and use a channel directly.
• For timeouts, specify the duration directly, e.g., timeout := time.Second (or 2 * time.Second for a 2-second timeout).

Helper Function

To simplify the process, a helper function can be created to encapsulate the timeout logic:

func waitTimeout(wg *sync.WaitGroup, timeout time.Duration) bool {
    c := make(chan struct{})
    go func() {
        defer close(c)
        wg.Wait()
    }()
    select {
    case <-c:
        return false // Completed normally
    case <-time.After(timeout):
        return true // Timed out
    }
}

This function wraps the timeout functionality and makes it easy to use:

if waitTimeout(&wg, time.Second) {
    fmt.Println("Timed out waiting for wait group")
} else {
    fmt.Println("Wait group finished")
}

This approach provides a cleaner and more convenient way to handle timeouts for WaitGroup.Wait() operations.

The above is the detailed content of How to Implement a Timed Wait for WaitGroup.Wait() in Go?. For more information, please follow other related articles on the PHP Chinese website!