context

Question 1

Context Basics

Answer 1

Purpose:
Carries deadlines, cancellation signals, and request-scoped values across API boundaries.

Creation:

ctx := context.Background()  // Root context
ctx = context.TODO()         // Temporary placeholder

Question 2

Cancellation

Answer 2

WithCancel:

ctx, cancel := context.WithCancel(parentCtx)
defer cancel()  // Release resources
go func() {
    <-ctx.Done()  // Triggered on cancel()
    fmt.Println("Canceled:", ctx.Err())  // "context canceled"
}()
cancel()  // Propagates cancellation

Question 3

Deadlines

Answer 3

WithDeadline:

deadline := time.Now().Add(2 * time.Second)
ctx, cancel := context.WithDeadline(parentCtx, deadline)
defer cancel()

select {
case <-time.After(3 * time.Second):
    fmt.Println("Work completed")
case <-ctx.Done():
    fmt.Println("Deadline exceeded:", ctx.Err())  // "context deadline exceeded"
}

Question 4

Timeouts

Answer 4

WithTimeout:

ctx, cancel := context.WithTimeout(parentCtx, 100*time.Millisecond)
defer cancel()

Equivalent to:

WithDeadline(parentCtx, time.Now().Add(100*time.Millisecond))

Question 5

Context Values

Answer 5

WithValue:

type key string
ctx := context.WithValue(parentCtx, key("user"), "Alice")

if val := ctx.Value(key("user")); val != nil {
    fmt.Println("User:", val)  // "User: Alice"
}

Key Rules:
1. Use custom types for keys (avoid string)
2. Values should be immutable
3. Don’t abuse for dependency injection

Question 6

Context in HTTP

Answer 6

Server:

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    select {
    case <-time.After(5 * time.Second):
        w.Write([]byte("Done"))
    case <-ctx.Done():
        fmt.Println("Request canceled")
    }
})

Client:

req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
client.Do(req)  // Respects context cancellation

Question 7

Best Practices

Answer 7

1. Propagate contexts through call chains
2. Always call cancel() to avoid leaks
3. Prefer explicit timeout/deadline over Background()
4. Never store mutable objects in values
5. Context should be first parameter (convention)

Question 8

Error Handling

Answer 8

Check Errors:

<-ctx.Done()
switch ctx.Err() {
case context.Canceled:
    // Manual cancellation
case context.DeadlineExceeded:
    // Timeout reached
}

Question 9

Common Patterns

Answer 9

Database Query:

rows, err := db.QueryContext(ctx, "SELECT...")
if errors.Is(err, context.Canceled) {
    // Handle cancellation
}

gRPC:

resp, err := client.SomeRPC(ctx, request)

Question 10

Anti-Patterns

Answer 10

❌ Storing contexts in structs
❌ Using for non-request-scoped data
❌ Ignoring ctx.Done() in long-running ops
❌ Mixing cancellation signals