In Go, handling requests efficiently often requires maintaining and relaying contextual information. This is where the context package comes to the rescue. The context package is used to define a context associated with a request that you can pass down through functions to handle deadlines, cancellations, and other request-scoped values.
Why Use Context?
Using the context package helps propagate cancellation signals and request-scoped data across API boundaries and between processes. The main benefits include:
- Cancellation: Ability to cancel multiple goroutines when a parent request is cancelled.
- Timeouts: Set timeouts on request handling to prevent hanging operations.
- Pass Values: Transfer metadata or context-specific data using context values.
Creating a Context
The most common place to obtain a new Context is using the context.Background() or context.TODO() functions. Here's an example:
package main
import (
"context"
"fmt"
"time"
)
func main() {
ctx := context.Background()
fmt.Println("Context created:", ctx)
}
Context with Cancellation
One common pattern is using a context to cancel operations upon completion or in case of a timeout. You can create a cancellable context using context.WithCancel.
ctx, cancel := context.WithCancel(context.Background())
// Perform an operation
cancel() // Cancels the context signal to all derived contexts
Here is a complete example that cancels a long task if it's still running after some seconds:
func main() {
ctx, cancel := context.WithCancel(context.Background())
go func() {
time.Sleep(2 * time.Second) // Simulating operation
cancel()
}()
select {
case <-ctx.Done():
fmt.Println("Operation cancelled")
}
}
Context with Timeout
Using a timeout is similar to using a cancelable context. Here is an example using context.WithTimeout:
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel() // ensure resources are freed
select {
case <-time.After(5 * time.Second):
fmt.Println("Completed without timeout")
case <-ctx.Done():
fmt.Println("Timeout, context cancelled")
}
}
Context with Values
Passing values down through functions is another useful aspect of contexts. However, keep in mind that context should not be used as a datastore. Here is an example of how you can add a value and retrieve it:
type key string
func main() {
ctx := context.WithValue(context.Background(), key("userID"), "12345")
id := ctx.Value(key("userID")).(string)
fmt.Println("UserID is", id)
}
Best Practices
- Contexts are immutable, always create a new context.
- Be careful about context use in long call chains to prevent unwanted leaks.
- Avoid storing complex data within context to maintain clarity.
The power of the context package is, without a doubt, invaluable as you build robust and resilient Go applications. Understanding these patterns and incorporating contexts into your request-handling workflows can go a long way in improving the scalability and maintainability of your software.
