一文搞懂Go语言Context：原理、用法与实战示例

向北走

发布时间：2026-10-15 | 3人浏览过

原创

在Go并发编程中，context是控制goroutine生命周期和传递请求作用域数据的核心机制。本文详细讲解如何结合sync.WaitGroup使用Context，以及利用WithCancel、WithTimeout和WithValue实现优雅的超时报错、资源释放和跨协程参数传递。

前置知识：sync.WaitGroup基础

在使用Context前，了解sync.WaitGroup是必要的，它常用于等待一组协程结束。它维护一个计数器：Add()增加计数，Done()（即Add(-1)）减少计数。Wait()会阻塞直到计数归零。

操作说明：定义全局或局部group sync.WaitGroup，启动协程前Add(数量)，协程结束时defer group.Done()。

package main
import (
    "fmt"
    "sync"
    "time"
)
var group sync.WaitGroup

func sayHello() {
    for i := 0; i < 5; i++ {
        fmt.Println("hello......")
        time.Sleep(time.Second)
    }
    group.Done()
}

func sayHi() {
    defer group.Done()
    for i := 0; i < 5; i++ {
        fmt.Println("hi......")
        time.Sleep(time.Second)
    }
}

func main() {
    group.Add(2)
    go sayHello()
    go sayHi()
    group.Wait()
    fmt.Println("all done")
}

Context简介与核心价值

在Go服务器中，每个请求都在独立的goroutine处理，并可能衍生出更多子协程。当请求取消或超时，所有相关协程都应快速退出以回收资源。context包提供了标准机制，用于跨API边界传递取消信号、截止日期和请求范围的值。

关键规则：不要将Context存储在结构体中，应作为第一个参数显式传递给需要它的函数；即使不确定用途，也请使用context.TODO()而非nil。同一个Context可安全地被多个goroutine同时访问。

Context接口定义

context.Context是一个包含四个方法的接口，定义了Context的行为：

type Context interface {
    Done() <-chan struct{}
    Err() error
    Deadline() (deadline time.Time, ok bool)
    Value(key interface{}) interface{}
}

Done()：返回通道。关闭时意味着Context被取消或超时。协程应在该通道关闭时退出。
Err()：返回取消的原因错误。
Deadline()：返回截止时间。
Value()：获取与该Key关联的值。

常用工厂函数解析

第1步：初始化根Context

目的：创建不会自动取消的顶层上下文。

context.Background()：空的根Context，通常用于main函数或测试。
context.TODO()：不知道用哪个Context时占位使用。

第2步：实现手动取消（WithCancel）

目的：允许程序在特定条件下主动触发所有子协程退出。

操作：ctx, cancel := context.WithCancel(parent)。调用cancel()后，ctx.Done()通道关闭。

package main
import (
    "context"
    "fmt"
)

func play(ctx context.Context) <-chan int {
    dist := make(chan int)
    n := 1
    go func() {
        for {
            select {
            case <-ctx.Done():
                return // 防止协程泄露
            case dist <- n:
                n++
            }
        }
    }()
    return dist
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    for n := range play(ctx) {
        fmt.Println(n)
        if n == 5 {
            break
        }
    }
}

第3步：实现定时取消（WithTimeout/WithDeadline）

目的：防止请求处理时间过长，设置硬性的超时限制。

操作：WithTimeout接收持续时间，WithDeadline接收具体时间戳。当计时器耗尽或到达指定时间，Context自动取消。

超时示例：

package main
import (
    "context"
    "fmt"
    "time"
    "sync"
)

var wg sync.WaitGroup

func worker(ctx context.Context) {
LOOP:
    for {
        fmt.Println("working...")
        time.Sleep(time.Millisecond * 10)
        select {
        case <-ctx.Done():
            break LOOP
        default:
        }
    }
    fmt.Println("worker finished")
    wg.Done()
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
    defer cancel()
    wg.Add(1)
    go worker(ctx)
    wg.Wait()
}

第4步：传递请求级参数（WithValue）

目的：在goroutine链中透明地传递如用户ID、TraceID等非函数形参的上下文信息。

注意：仅用于传输流程控制的数据，不应替代函数参数。

示例：

package main
import (
    "context"
    "fmt"
    "sync"
    "time"
)

type TraceCode string
var wg sync.WaitGroup

func worker(ctx context.Context) {
    // 提取trace code
    code := ctx.Value(TraceCode("KEY_CODE"))
    if code != nil {
        fmt.Printf("Worker has trace: %v\n", code)
    }

    // 模拟工作受超时影响
    select {
    case <-ctx.Done():
        fmt.Println("Stopped due to timeout/cancel")
    case <-time.After(time.Millisecond * 60):
        fmt.Println("Work completed")
    }
    wg.Done()
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
    defer cancel()
    
    // 挂载值
    ctx = context.WithValue(ctx, TraceCode("KEY_CODE"), "12345-ABC")
    
    wg.Add(1)
    go worker(ctx)
    wg.Wait()
}

实战：HTTP请求中的Context超时控制

在实际后端开发中，常需为外部请求设置超时。下面展示Client端如何利用Context拦截Server端的慢响应。

步骤： 1. Client创建带超时Context：ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)。 2. 将Context绑定到Request：req = req.WithContext(ctx)。ctx.Done()，一旦超时立即返回，避免协程泄漏。

package main
import (
    "context"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

func doCall(ctx context.Context) {
    client := &http.Client{} // 实际生产中建议复用transport
    req, _ := http.NewRequest("GET", "http://example.com/slow-endpoint", nil)
    req = req.WithContext(ctx)

    respChan := make(chan string, 1)
    go func() {
        resp, err := client.Do(req)
        if err != nil {
            respChan <- fmt.Sprintf("Error: %v", err)
            return
        }
        defer resp.Body.Close()
        data, _ := ioutil.ReadAll(resp.Body)
        respChan <- string(data)
    }()

    select {
    case <-ctx.Done():
        fmt.Println("Request timed out or cancelled")
    case result := <-respChan:
        fmt.Println("Response:", result)
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()
    doCall(ctx)
}