context的使用场景

在 Go 语言中，context 包提供了一种在 goroutine 之间传递信号的方法，用于管理请求的生命周期和控制并发操作。context 主要用于以下几个场景：

1. 控制请求的生命周期

场景描述

  • 在处理 HTTP 请求时，通常需要确保请求处理过程中能够及时取消、超时或结束。这尤其重要当请求涉及多个下游服务调用时，若一个服务响应缓慢或失败，必须取消所有其他正在进行的操作。

使用示例

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    resultChan := make(chan string)

    go func() {
        // 模拟耗时操作
        time.Sleep(2 * time.Second)
        resultChan <- "result"
    }()

    select {
    case <-ctx.Done():
        // 请求取消或超时
        http.Error(w, "request canceled", http.StatusRequestTimeout)
    case result := <-resultChan:
        // 正常返回结果
        fmt.Fprintln(w, result)
    }
}
  • 解释：在这个例子中，通过 ctx.Done() 来监听请求是否被取消或超时，从而决定是否终止操作。

2. 处理超时和截止日期

场景描述

  • 当处理需要网络调用或长时间运行的操作时，设定一个超时时间或截止日期是很重要的。context 可以传递一个超时或截止日期，自动取消操作，避免资源的浪费。

使用示例

func fetchData(ctx context.Context) (string, error) {
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()

    ch := make(chan string, 1)
    go func() {
        // 模拟耗时操作
        time.Sleep(3 * time.Second)
        ch <- "data"
    }()

    select {
    case <-ctx.Done():
        return "", ctx.Err() // 返回超时或取消错误
    case result := <-ch:
        return result, nil
    }
}
  • 解释：context.WithTimeout 创建了一个带有超时的 context，当操作超过指定时间后，ctx.Done() 会被触发。

3. 传递元数据

场景描述

  • 在微服务架构中，可能需要在服务之间传递一些与请求相关的元数据，例如认证信息、跟踪 ID 等。context 提供了传递这些信息的方式。

使用示例

func main() {
    ctx := context.Background()
    ctx = context.WithValue(ctx, "requestID", "12345")

    processRequest(ctx)
}

func processRequest(ctx context.Context) {
    reqID := ctx.Value("requestID")
    fmt.Println("Request ID:", reqID)
}
  • 解释：context.WithValue 可以将请求的元数据存储在 context 中，并在整个请求链中传递和访问。

4. 协同工作

场景描述

  • 在复杂的并发任务中，不同的 goroutine 可能需要相互协作，或需要在特定条件下取消其他 goroutine。context 可以用于协同工作，统一管理多个 goroutine 的状态。

使用示例

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    go worker(ctx, "worker1")
    go worker(ctx, "worker2")

    time.Sleep(1 * time.Second)
    cancel() // 取消所有工作

    time.Sleep(1 * time.Second)
}

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println(name, "stopped")
            return
        default:
            fmt.Println(name, "working")
            time.Sleep(500 * time.Millisecond)
        }
    }
}
  • 解释：context.WithCancel 创建了一个可以手动取消的 context，通过 cancel() 函数可以取消所有与该 context 关联的操作。

5. 限制并发数量

场景描述

  • 在某些情况下，需要限制并发执行的 goroutine 的数量，避免过度消耗系统资源。context 可以与信号量或 sync.WaitGroup 一起使用来实现并发控制。

使用示例

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    sem := make(chan struct{}, 3) // 限制并发数为3
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            sem <- struct{}{} // 获取信号
            defer func() { <-sem }() // 释放信号

            worker(ctx, i)
        }(i)
    }

    wg.Wait()
}

func worker(ctx context.Context, id int) {
    select {
    case <-ctx.Done():
        fmt.Printf("worker %d canceled\n", id)
        return
    default:
        fmt.Printf("worker %d working\n", id)
        time.Sleep(1 * time.Second)
    }
}
  • 解释：在这个例子中，信号量用于限制同时运行的 goroutine 数量，而 context 用于在需要时取消所有工作。

6. 总结

context 在 Go 语言中主要用于管理请求的生命周期、处理超时、传递元数据、协同工作和限制并发。它提供了一种简洁且强大的方式来管理复杂的并发操作，特别是在涉及多个 goroutine 时。通过合理使用 context，可以编写更健壮、更可控的并发程序。