Use context to propagate cancellation and deadlines across goroutines, enabling cooperative cancellation in HTTP servers, background tasks, and chained calls. 2. With context.WithCancel(), create a cancellable context and call cancel() to signal termination, always deferring cancel() to prevent leaks. 3. For timeouts, use context.WithTimeout() to limit operation duration, checking ctx.Done() or ctx.Err() to handle deadline exceeded errors. 4. In HTTP handlers, extend the request context with a timeout and pass it downstream, ensuring backend operations respect client request lifecycle. 5. Best practices include always calling cancel(), passing context as first parameter, avoiding context storage in structs, preferring WithTimeout over time.After, and using context.Background() for root contexts. 6. Avoid common pitfalls like forgetting to call cancel(), ignoring ctx.Err(), or overusing context for non-request data. Proper context usage ensures resilient, responsive Go applications where cancellable operations are explicitly managed and resources are efficiently released.

When building concurrent applications in Go, handling cancellation and timeouts gracefully is essential. The context package provides a clean and efficient way to manage request-scoped values, cancellation signals, and deadlines across goroutines. It’s especially useful in HTTP servers, background tasks, and systems with chained function calls.

Here’s how to use the context package effectively for cancellation and timeouts.

1. Why Use Context?

Without context, it’s hard to tell a running goroutine to stop—especially if it’s blocked on I/O or waiting for a slow dependency. The context.Context type allows you to propagate cancellation signals and deadlines down through your call stack, enabling cooperative cancellation.

Common use cases:

• Canceling an HTTP request if the client disconnects.
• Timing out a database query.
• Stopping background workers when a service shuts down.

2. Basic Cancellation with Context

To cancel a goroutine, use context.WithCancel():

package main

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

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // Ensure cancel is called to release resources

    go func(ctx context.Context) {
        for {
            select {
            case <-ctx.Done():
                fmt.Println("Worker canceled:", ctx.Err())
                return
            default:
                fmt.Println("Working...")
                time.Sleep(500 * time.Millisecond)
            }
        }
    }(ctx)

    // Simulate work for 2 seconds
    time.Sleep(2 * time.Second)
    cancel() // Signal cancellation

    time.Sleep(1 * time.Second) // Let cleanup finish
}

Key points:

• context.WithCancel() returns a derived context and a cancel function.
• Calling cancel() triggers the Done() channel to close.
• Always call cancel() to avoid memory leaks—even if you don’t expect early cancellation.

3. Setting Timeouts with Context

Use context.WithTimeout() when you want to limit how long an operation can take:

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

resultChan := make(chan string, 1)
go func() {
    // Simulate a slow operation
    time.Sleep(5 * time.Second)
    resultChan <- "operation complete"
}()

select {
case res := <-resultChan:
    fmt.Println(res)
case <-ctx.Done():
    fmt.Println("Operation timed out:", ctx.Err())
}

Output:

Operation timed out: context deadline exceeded

• ctx.Err() returns context.DeadlineExceeded when the timeout is reached.
• Even if the goroutine keeps running, your main logic stops waiting.

4. Using Context in HTTP Handlers

In web servers, the incoming request already has a context. You can extend it with timeouts or pass it to downstream services.

func handler(w http.ResponseWriter, r *http.Request) {
    // Add a 2-second timeout to the request context
    ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
    defer cancel()

    result := slowDatabaseCall(ctx)
    if ctx.Err() == context.DeadlineExceeded {
        http.Error(w, "Request timed out", http.StatusGatewayTimeout)
        return
    }

    w.Write([]byte("Result: "   result))
}

func slowDatabaseCall(ctx context.Context) string {
    select {
    case <-time.After(3 * time.Second):
        return "data"
    case <-ctx.Done():
        return "" // Or log cancellation
    }
}

• r.Context() is automatically canceled if the client closes the connection.
• Adding a timeout ensures your backend doesn’t hang indefinitely.

5. Best Practices

• Always call cancel(): Use defer cancel() to release resources.
• Propagate context through APIs: Accept context.Context as the first parameter in functions that may block.
• Don’t store contexts in structs: Pass them explicitly as arguments.
• Prefer context.WithTimeout over time.After in selects: It’s cancellable and integrates better with the ecosystem.
• Use context.Background() for root contexts, and context.TODO() if you’re not sure yet.

6. Common Pitfalls

• Forgetting to call cancel() → leaks goroutines and memory.
• Ignoring ctx.Err() → miss cancellation signals.
• Using context for values you don’t need → overuse for non-request data (e.g., config) can hurt readability.

Using the context package properly makes your Go programs more resilient and responsive. Whether you're dealing with user requests, microservices, or background jobs, context gives you a standard way to manage lifetimes and avoid wasted work.

Basically, if a function might need to be canceled or timed out, it should take a context.

The above is the detailed content of Using the Context Package in Go for Cancellation and Timeouts. For more information, please follow other related articles on the PHP Chinese website!