Use context.WithTimeout to set controlled timeouts and always call cancel() to release resources. 2. Set explicit timeouts in HTTP clients using the Timeout field or configure granular timeouts with a custom Transport. 3. For channel operations, use select with time.After to avoid indefinite blocking, but prefer context or resettable timers in high-frequency scenarios to reduce memory overhead. 4. Apply context-aware methods like QueryContext and ExecContext for database queries to ensure timeout handling, provided the driver supports context. 5. Implement graceful shutdowns by calling server.Shutdown with a timeout-enabled context to allow active requests to complete. Always set timeouts on blocking operations, propagate context for cancellation, handle context.DeadlineExceeded explicitly, avoid time.After in loops, and test timeout behaviors to build reliable and resilient Go applications.

Handling timeouts properly is crucial in Go applications, especially when dealing with network requests, database calls, or any operation that might hang indefinitely. Go provides robust tools—primarily through the context package and time package—to manage timeouts effectively.

Here’s how to handle timeouts in different common scenarios:

1. Use context.WithTimeout for Controlled Timeouts

The most idiomatic way to handle timeouts in Go is using context.Context with a timeout. This allows you to cancel long-running operations and prevent resource leaks.

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

result, err := doSomething(ctx)
if err != nil {
    if err == context.DeadlineExceeded {
        log.Println("operation timed out")
    } else {
        log.Printf("operation failed: %v", err)
    }
}

Key points:

• Always call cancel() to release associated resources.
• Check for context.DeadlineExceeded to distinguish timeout errors.
• Pass the context through function calls (especially I/O-bound ones).

2. Timeouts in HTTP Clients

By default, http.Client has no timeout, which can cause your app to hang. Always set timeouts explicitly.

client := &http.Client{
    Timeout: 10 * time.Second, // total timeout for the request
}

resp, err := client.Get("https://api.example.com/data")
if err != nil {
    if err, ok := err.(net.Error); ok && err.Timeout() {
        log.Println("HTTP request timed out")
    } else {
        log.Printf("HTTP error: %v", err)
    }
}

For more granular control (e.g., separate timeouts for dialing, TLS handshake, etc.), use a custom Transport:

client := &http.Client{
    Transport: &http.Transport{
        DialContext: (&net.Dialer{
            Timeout:   2 * time.Second,
            KeepAlive: 30 * time.Second,
        }).DialContext,
        TLSHandshakeTimeout:   3 * time.Second,
        ResponseHeaderTimeout: 5 * time.Second,
        IdleConnTimeout:       60 * time.Second,
    },
    Timeout: 15 * time.Second,
}

3. Channel Operations with time.After

When dealing with channels, use select with time.After to avoid blocking forever.

select {
case msg := <-ch:
    fmt.Println("Received:", msg)
case <-time.After(3 * time.Second):
    fmt.Println("Timed out waiting for message")
}

This is useful in message queues, worker pools, or inter-goroutine communication.

?? Note: time.After creates a timer even if the channel receives quickly. For frequent operations, prefer context.WithTimeout or pre-allocated timers to avoid memory overhead.

4. Database Queries (e.g., with database/sql)

Database queries should also be timeout-aware. Use context-aware methods like QueryContext, ExecContext, etc.

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

rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE active = ?", true)
if err != nil {
    if err == context.DeadlineExceeded {
        log.Println("DB query timed out")
    } else {
        log.Printf("DB error: %v", err)
    }
}

Ensure your driver supports context (most modern ones like pq, mysql, pgx do).

5. Graceful Shutdown with Timeout

When shutting down a server, use timeouts to allow in-flight requests to complete.

srv := &http.Server{Addr: ":8080"}

// Graceful shutdown on signal
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
    <-c
    ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
    defer cancel()
    srv.Shutdown(ctx)
}()

log.Fatal(srv.ListenAndServe())

This ensures the server stops gracefully without killing active connections abruptly.

Best Practices Summary

• ? Always set timeouts on network operations.
• ? Use context for propagation and cancellation.
• ? Prefer context.WithTimeout over time.After in complex flows.
• ? Handle context.DeadlineExceeded explicitly.
• ? Avoid using time.After in tight loops—use time.NewTimer or reset timers.
• ? Test timeout paths (e.g., using mocked slow services).

Timeouts aren’t just about reliability—they’re about building predictable, resilient systems. In Go, combining context, time, and proper error handling gives you fine-grained control with minimal overhead.

Basically, if it can block, it should have a timeout.

The above is the detailed content of How to handle timeouts in Go applications?. For more information, please follow other related articles on the PHP Chinese website!