The context package in Go is a powerful tool for managing cancellation, deadlines, and request-scoped values across API boundaries and between processes. It's particularly useful in concurrent programming scenarios.

What is Context?

A Context in Go is an interface that provides methods for cancellation signaling, deadline management, and carrying request-scoped values. It's designed to be passed through your program's call stack, allowing you to propagate cancellation signals and manage the lifecycle of operations.

Key Features of Context

Cancellation signaling
Deadline management
Value propagation
Concurrency-safe

Creating a Context

There are several ways to create a Context:


// Create an empty context
ctx := context.Background()

// Create a context with cancellation
ctx, cancel := context.WithCancel(context.Background())

// Create a context with a deadline
ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(5 * time.Second))

// Create a context with a timeout
ctx, cancel := context.WithTimeout(context.Background(), 5 * time.Second)

Using Context for Cancellation

One of the primary uses of Context is to manage cancellation in concurrent operations. Here's an example:


func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Worker: Stopping due to cancellation")
            return
        default:
            fmt.Println("Worker: Doing work")
            time.Sleep(1 * time.Second)
        }
    }
}

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

    go worker(ctx)

    time.Sleep(6 * time.Second)
    fmt.Println("Main: Finished")
}

In this example, the worker function checks the context's Done channel to determine if it should stop. The main function creates a context with a 5-second timeout and passes it to the worker.

Context Values

Context also allows you to pass request-scoped values down a call chain:


ctx := context.WithValue(context.Background(), "user", "alice")
user := ctx.Value("user").(string)
fmt.Println(user) // Outputs: alice

Best Practices

Always pass Context as the first parameter to functions that may perform long-running operations.
Use Context values only for request-scoped data, not for passing optional parameters.
Don't store Contexts inside a struct type; instead, pass a Context explicitly to each function that needs it.
The cancel function should be called as soon as the operations running in this Context complete.

Related Concepts

To fully understand and utilize Context in Go, you might want to explore these related topics:

By mastering the Context package, you'll be able to write more robust and efficient concurrent Go programs, especially when dealing with timeouts, cancellations, and request-scoped data.