How do you handle timeouts in Go for blocking operations?

Handling timeouts for blocking operations in Go is a common requirement, especially when dealing with network requests or other operations that require waiting. Go provides several mechanisms for gracefully handling timeouts, with the most common being through the context package.

Using the context Package

The context package enables you to send cancellation signals to functions that might block, allowing them to gracefully interrupt execution by listening for these signals. Specifically, you can use context.WithTimeout to set the timeout duration.

Example

Here is an example using context to implement timeout control:

go
package main

import (
    "context"
    "fmt"
    "time"
)

func operation(ctx context.Context) {
    select {
    case <-time.After(5 * time.Second): // Simulate a time-consuming operation
        fmt.Println("operation finished")
    case <-ctx.Done():
        fmt.Println("operation cancelled")
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    go operation(ctx)

    select {
    case <-ctx.Done():
        switch ctx.Err() {
        case context.DeadlineExceeded:
            fmt.Println("deadline exceeded")
        case context.Canceled:
            fmt.Println("context was canceled")
        }
    }
}

In this example, the operation function would print "operation finished" after 5 seconds, but the main function sets a 3-second timeout. Consequently, when the timeout is reached, the Done channel of the context is signaled, causing "deadline exceeded" to be printed, and ctx.Done() in the operation function is triggered, resulting in "operation cancelled" being printed.

Using time.After and select

If you don't require full cancellation signal control, you can use the time.After function with a select statement to implement simple timeout logic:

go
package main

import (
    "fmt"
    "time"
)

func operation() {
    // Simulate a time-consuming operation
    time.Sleep(5 * time.Second)
    fmt.Println("operation finished")
}

func main() {
    timeout := time.After(3 * time.Second)
    done := make(chan bool)

    go func() {
        operation()
        done <- true
    }()

    select {
    case <-done:
        fmt.Println("operation done without timeout")
    case <-timeout:
        fmt.Println("operation timeout")
    }
}

In this example, if operation completes within 3 seconds, a signal is sent through the done channel, and select prints "operation done without timeout". If it doesn't complete within 3 seconds, the channel from time.After sends a timeout signal, and select prints "operation timeout".

Summary

Using the context package is a more flexible and general approach for handling timeouts, as it not only manages timeouts but also propagates cancellation signals and other request-level values. In contrast, using time.After and select is suitable for simple timeout scenarios where no additional context information needs to be managed.