How do you handle errors in concurrent Go code?

Handling errors in concurrent Go code is an important topic because concurrent operations can easily lead to issues such as race conditions and deadlocks. Proper error handling ensures the robustness and reliability of the program. Here are some strategies for handling errors in concurrent Go code:

1. Using sync.WaitGroup to wait for concurrent tasks to complete

sync.WaitGroup is used to wait for a set of concurrent operations to complete. Each goroutine calls WaitGroup.Add(1) at the start and WaitGroup.Done() upon completion. The main goroutine blocks by calling WaitGroup.Wait() until all goroutines finish. This method ensures that all goroutines complete, but requires manual error handling for each goroutine.

Example code:

go
var wg sync.WaitGroup
var mu sync.Mutex
var errors []error

for _, task := range tasks {
    wg.Add(1)
    go func(task Task) {
        defer wg.Done()
        if err := task.Process(); err != nil {
            mu.Lock()
            errors = append(errors, err)
            mu.Unlock()
        }
    }(task)
}

wg.Wait()

if len(errors) > 0 {
    fmt.Println("Encountered errors: ", errors)
}

2. Using channel to collect errors

Using channels to propagate errors is another common pattern. Each goroutine can send errors to a common error channel, and the main goroutine can read and handle these errors from the channel.

Example code:

go
errors := make(chan error, len(tasks))
done := make(chan bool, 1)

go func() {
    for _, task := range tasks {
        go func(task Task) {
            if err := task.Process(); err != nil {
                errors <- err
            }
        }(task)
    }

    done <- true
}()

<-done
close(errors)

for err := range errors {
    if err != nil {
        fmt.Println("Error encountered:", err)
    }
}

3. Using context to manage timeouts and cancellation

context.Context is the standard way in Go to control the lifecycle of goroutines. It can be used to handle timeouts, cancellation, and propagate values across request scope.

Example code:

go
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

for _, task := range tasks {
    go func(task Task) {
        select {
        case <-ctx.Done():
            fmt.Println("Operation cancelled or timed out")
        default:
            if err := task.Process(); err != nil {
                fmt.Println("Error: ", err)
            }
        }
    }(task)
}

Summary

Handling errors in Go involves designing comprehensive error propagation mechanisms and appropriate synchronization tools. Proper use of sync.WaitGroup, channel, and context not only helps synchronize goroutines but also provides sufficient information for appropriate error handling when errors occur. It is important to understand the appropriate use cases for each tool and choose the most suitable method based on specific requirements.