Golang并发编程中Context包的使用与并发控制_Golang

一、简介

在并发编程中，任务管理和资源控制是非常重要的，而 golang 的 context 包为我们提供了一种优雅的方式来传递取消信号和超时控制。context 用于在多个 goroutine 之间传递上下文信息，避免 goroutine 无法按需停止而导致资源浪费。

本篇博客将详细介绍 context 包的用法，并通过实例讲解如何在超时、取消任务和多 goroutine 协作场景中使用它。

二、context 的基本概念

context 是一种携带取消信号、截止时间（超时）和元数据的上下文对象，主要用于父 goroutine 与子 goroutine 的协作。它通过层级化的结构来管理多个并发任务。

1. context 包常用函数

context.background()：创建根上下文，通常用于程序入口。
context.todo()：占位符上下文，表示未来会替换为实际上下文。
context.withcancel(parent context)：创建带取消功能的子上下文。
context.withtimeout(parent context, timeout time.duration)：创建带超时功能的子上下文。
context.withdeadline(parent context, deadline time.time)：基于指定的截止时间创建上下文。
context.withvalue(parent context, key, value interface{})：传递携带额外数据的上下文。

三、context 的基本用法

1. withcancel：取消任务的上下文

示例：使用 withcancel 取消 goroutine

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.context, id int) {
    for {
        select {
        case <-ctx.done(): // 接收取消信号
            fmt.printf("worker %d stopped\n", id)
            return
        default:
            fmt.printf("worker %d is working...\n", id)
            time.sleep(time.second)
        }
    }
}

func main() {
    ctx, cancel := context.withcancel(context.background()) // 创建可取消的上下文

    for i := 1; i <= 3; i++ {
        go worker(ctx, i)
    }

    time.sleep(3 * time.second) // 模拟主 goroutine 的其他工作
    fmt.println("cancelling all workers...")
    cancel() // 发送取消信号

    time.sleep(1 * time.second) // 等待所有 goroutine 退出
    fmt.println("all workers stopped.")
}

输出：

worker 1 is working...
worker 2 is working...
worker 3 is working...
...
cancelling all workers...
worker 1 stopped
worker 2 stopped
worker 3 stopped
all workers stopped.

解析：

context.withcancel 创建的上下文可以通过调用 cancel() 发送取消信号，从而优雅地停止所有子 goroutine。

四、超时控制：withtimeout 和 withdeadline

1. 使用 withtimeout 控制任务超时

示例：在 2 秒内完成任务，否则超时退出

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.context) {
    select {
    case <-time.after(3 * time.second): // 模拟长时间任务
        fmt.println("task completed")
    case <-ctx.done(): // 接收超时信号
        fmt.println("task timed out")
    }
}

func main() {
    ctx, cancel := context.withtimeout(context.background(), 2*time.second) // 设置 2 秒超时
    defer cancel() // 确保资源释放

    go worker(ctx)

    time.sleep(4 * time.second) // 等待任务完成或超时
}

输出：

task timed out

解析：

通过 context.withtimeout 创建的上下文，2 秒内未完成任务时自动发送取消信号。
超时上下文可避免 goroutine 无限期运行，帮助更好地管理资源。

2. 使用 withdeadline 设定截止时间

withdeadline 和 withtimeout 类似，只是使用具体的时间点来控制超时。

五、传递上下文中的数据：withvalue

有时，我们需要在多个 goroutine 之间传递一些元数据。withvalue 允许我们将键值对存入上下文，并在子 goroutine 中访问。

示例：传递用户信息

package main

import (
    "context"
    "fmt"
    "time"
)

func greetuser(ctx context.context) {
    if user, ok := ctx.value("user").(string); ok {
        fmt.printf("hello, %s!\n", user)
    } else {
        fmt.println("no user found.")
    }
}

func main() {
    ctx := context.withvalue(context.background(), "user", "alice") // 在上下文中存入用户信息
    go greetuser(ctx)

    time.sleep(1 * time.second) // 确保 goroutine 执行完毕
}

输出：

hello, alice!

解析：

withvalue 允许我们为上下文设置键值对，便于在多 goroutine 间传递数据。

注意：

不建议用 withvalue 传递重要的控制信息，例如取消信号或超时。

六、context 的应用场景

api 请求的超时控制：确保 http 请求不会无限期等待。
任务取消：当用户主动取消某个操作时，通知相关的 goroutine 停止工作。
传递元数据：例如在服务链路中传递用户身份、请求 id 等信息。

七、完整示例：多任务协作控制

示例：启动多个任务，随时可取消所有任务

package main

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

func worker(ctx context.context, id int, wg *sync.waitgroup) {
    defer wg.done()

    for {
        select {
        case <-ctx.done():
            fmt.printf("worker %d stopped\n", id)
            return
        default:
            fmt.printf("worker %d is processing...\n", id)
            time.sleep(500 * time.millisecond)
        }
    }
}

func main() {
    var wg sync.waitgroup
    ctx, cancel := context.withcancel(context.background()) // 创建上下文

    for i := 1; i <= 3; i++ {
        wg.add(1)
        go worker(ctx, i, &wg)
    }

    time.sleep(2 * time.second)
    fmt.println("cancelling all workers...")
    cancel() // 取消所有任务

    wg.wait() // 等待所有任务完成
    fmt.println("all workers stopped.")
}

输出：

worker 1 is processing...
worker 2 is processing...
worker 3 is processing...
...
cancelling all workers...
worker 1 stopped
worker 2 stopped
worker 3 stopped
all workers stopped.