Introduction
Context solves the problem: "How do I gracefully stop operations or set timeouts across multiple goroutines?"
Key Insight
Context provides cooperative cancellation -> you control when and how to check for cancellation, not abrupt force-killing.
Creating Contexts
1. WithTimeout -> Automatic cancellation after duration
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
2. WithCancel -> Manual cancellation
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
cancel()
3. Background -> Root context
ctx := context.Background()
How Cancellation Works
The cooperative pattern
func worker(ctx context.Context, name string) {
for {
select {
case <-ctx.Done():
fmt.Printf("%s: Got cancellation signal\n", name)
cleanup()
fmt.Printf("%s: Cleaned up, exiting gracefully\n", name)
return
default:
fmt.Printf("%s: working...\n", name)
time.Sleep(500 * time.Millisecond)
}
}
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
go worker(ctx, "Worker 1")
go worker(ctx, "Worker 2")
go worker(ctx, "Worker 3")
time.Sleep(2 * time.Second)
cancel()
time.Sleep(1 * time.Second)
}
What happens step by step
Workers start: Enter infinite for loop
Select checks: "Is ctx.Done() ready to receive?"
If NOT cancelled: Goes to default, does work, loops again
When cancel() called: ctx.Done() channel gets closed
Next time workers hit select: ctx.Done() case executes
Workers clean up: Do whatever cleanup they want
Workers exit: When THEY decide to return
Different checking patterns
Pattern 1 -> Check every iteration
func worker(ctx context.Context) {
for {
select {
case <-ctx.Done():
return
default:
}
doWork()
}
}
Pattern 2 -> Check periodically
func worker(ctx context.Context) {
for i := 0; i < 1000000; i++ {
processItem(i)
if i%1000 == 0 {
select {
case <-ctx.Done():
fmt.Printf("Cancelled at item %d\n", i)
return
default:
}
}
}
}
Pattern 3 -> Racing work vs cancellation
func fetchData(ctx context.Context) (string, error) {
result := make(chan string)
go func() {
time.Sleep(5 * time.Second)
result <- "data"
}()
select {
case data := <-result:
return data, nil
case <-ctx.Done():
return "", ctx.Err()
}
}
Timeout Example
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
result := make(chan string)
go slowWork(ctx, result)
select {
case data := <-result:
fmt.Println("Got result:", data)
case <-ctx.Done():
fmt.Println("Timeout! Work took too long")
fmt.Println("Error:", ctx.Err())
}
}
func slowWork(ctx context.Context, result chan string) {
select {
case <-time.After(3 * time.Second):
result <- "finished work"
case <-ctx.Done():
fmt.Println("Work cancelled due to timeout")
return
}
}
Context Propagation
func handleRequest(ctx context.Context) {
data := fetchFromAPI(ctx)
processData(ctx, data)
saveToDatabase(ctx, data)
}
func fetchFromAPI(ctx context.Context) string {
select {
case <-time.After(1 * time.Second):
return "api data"
case <-ctx.Done():
return ""
}
}
Key Points
1. Cooperative Nature
Context doesn't force-kill anything. Your goroutines choose when to check and how to respond.
2. Graceful Shutdown
You can clean up, save state, close files, etc. before exiting.
3. Propagation
One context can control an entire tree of operations.
4. Channel Syntax
<-ctx.Done() receives from the Done() channel, which becomes ready when context is cancelled.
5. Always call cancel()
Even with timeout contexts, call cancel() to free resources.
