Use context.WithTimeout to create a cancellable context with a deadline and always call cancel() to release resources. 2. For HTTP requests, set timeouts using http.Client.Timeout or use context via http.NewRequestWithContext for per-request control. 3. In goroutines with channels, use select with time.After to avoid blocking indefinitely, preferring time.NewTimer in loops to avoid timer leaks. 4. For low-level connections, set deadlines using SetDeadline, SetReadDeadline, or SetWriteDeadline on network connections. Always handle context.DeadlineExceeded explicitly, prefer context-based timeouts for flexibility, and clean up resources promptly to ensure reliable and responsive Go applications.

Handling timeouts in Go is essential for building reliable and responsive applications, especially when dealing with network requests, database calls, or any operation that might block indefinitely. Go provides clean, idiomatic ways to manage timeouts using context and time packages.

Here’s how to handle timeouts effectively:

1. Use context.WithTimeout for controlled cancellation

The most common and recommended way to handle timeouts in Go is with context. You can create a context that automatically cancels after a specified duration.

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)
    }
}

In this example:

• doSomething must accept a context.Context and respect cancellation.
• If the operation takes longer than 5 seconds, the context is canceled, and ctx.Done() is triggered.
• You can check ctx.Err() to see if the reason was context.DeadlineExceeded.

? Best practice: Always call cancel() to release associated resources (timer), even if the timeout hasn’t fired.

2. Apply timeouts to HTTP clients

When making HTTP requests, you should avoid letting them hang forever. You can set timeouts both at the client level and per request using context.

Option A: Set timeout on HTTP client

client := &http.Client{
    Timeout: 10 * time.Second,
}

resp, err := client.Get("https://httpbin.org/delay/15")
if err != nil {
    log.Printf("request failed: %v", err)
    return
}
defer resp.Body.Close()

This sets a total timeout for the entire request (connect data transfer).

Option B: Use context for fine-grained control

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

req, _ := http.NewRequest("GET", "https://httpbin.org/delay/15", nil)
req = req.WithContext(ctx) // Deprecated in Go 1.13 , use Context() field

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    log.Printf("request failed: %v", err)
    return
}
defer resp.Body.Close()

? Note: Since Go 1.13, you don’t need req.WithContext(). Just set the context on the request directly:

req := http.NewRequestWithContext(ctx, "GET", url, nil)

3. Handle timeouts in channels and goroutines

When coordinating between goroutines using channels, always protect against blocking with select and time.After.

ch := make(chan string)

go func() {
    time.Sleep(3 * time.Second)
    ch <- "data received"
}()

select {
case data := <-ch:
    fmt.Println(data)
case <-time.After(2 * time.Second):
    fmt.Println("timeout: no data received")
}

• time.After(d) returns a channel that sends the current time after duration d.
• This prevents your program from hanging if the goroutine takes too long.

?? Warning: time.After creates a timer even if unused. In hot loops, prefer time.NewTimer and call .Stop().

4. Set deadlines on connections (advanced)

For low-level control (e.g., TCP connections), you can set read/write deadlines:

conn, _ := net.Dial("tcp", "example.com:80")
conn.SetDeadline(time.Now().Add(5 * time.Second)) // Both read and write

_, err := conn.Write([]byte("GET / HTTP/1.0\r\n\r\n"))
if err != nil {
    log.Printf("write failed: %v", err)
}

_, err = conn.Read(buf)
if err != nil {
    log.Printf("read failed: %v", err)
}

Use SetReadDeadline, SetWriteDeadline, or SetDeadline as needed.

Summary of best practices

• ? Always use context.WithTimeout for cancellable operations.
• ? Always call the cancel() function to avoid resource leaks.
• ? Use http.Client with timeouts or http.NewRequestWithContext.
• ? Use select time.After for channel-based operations.
• ? Prefer context-based timeouts over global client timeouts for flexibility.
• ? Don’t ignore context.DeadlineExceeded — handle it explicitly.

Timeouts are not just about performance — they're crucial for system stability. By combining context, time.After, and proper cancellation, you can write Go programs that fail fast and recover gracefully.

Basically, just remember: use context for control, set limits everywhere, and always clean up.

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