Golang使用context控制并发任务生命周期

P粉602998670

发布时间：2025-09-04 08:17:01

467人浏览过

来源于php中文网

原创

使用context.WithCancel可取消goroutine，调用cancel()后所有监听该context的goroutine通过ctx.Done()收到信号并退出。

golang使用context控制并发任务生命周期

在Golang中，

context

包提供了一种优雅的方式来管理并发任务的生命周期，包括取消、超时和传递请求相关的值。它允许你构建更健壮、更可控的并发程序。

使用

context

可以控制并发任务的启动、停止和传递请求范围的数据。

如何使用Context取消一个goroutine？

context.WithCancel

函数是实现取消goroutine的关键。它返回一个

context

和一个

CancelFunc

。调用

CancelFunc

会取消

context

，所有监听该

context

的goroutine都会收到取消信号。

package main

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

func worker(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d: 任务取消\n", id)
            return
        default:
            fmt.Printf("Worker %d: 正在工作中...\n", id)
            time.Sleep(time.Second)
        }
    }
}

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

    // 启动多个worker goroutine
    for i := 1; i <= 3; i++ {
        go worker(ctx, i)
    }

    // 模拟一段时间后取消任务
    time.Sleep(3 * time.Second)
    fmt.Println("准备取消所有worker...")
    cancel()

    // 等待一段时间，确保所有worker都已退出
    time.Sleep(time.Second)
    fmt.Println("所有worker已退出，程序结束")
}

在这个例子中，我们创建了一个带有取消功能的

context

。启动了三个

worker

goroutine，每个goroutine都在循环中执行任务，并监听

context.Done()

通道。当调用

cancel()

函数时，

context

被取消，所有

worker

goroutine收到信号并退出。我个人觉得这种方式比直接使用channel发送信号更加优雅，尤其是当你需要传递多个取消信号的时候。

立即学习“go语言免费学习笔记（深入）”；

Context的超时控制是如何实现的？

context.WithTimeout

函数允许你设置一个超时时间。当超过指定时间后，

context

会自动取消。这对于防止goroutine无限期地阻塞非常有用。

package main

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

func longRunningTask(ctx context.Context) {
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("任务完成")
    case <-ctx.Done():
        fmt.Println("任务超时取消")
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel() // 确保即使任务提前完成，cancel也会被调用

    go longRunningTask(ctx)

    select {
    case <-ctx.Done():
        fmt.Println("主程序检测到任务超时")
    case <-time.After(6 * time.Second): // 稍微长于longRunningTask，确保其完成或超时
        fmt.Println("主程序结束")
    }
}

在这个例子中，

longRunningTask

模拟一个需要5秒才能完成的任务。我们使用

context.WithTimeout

设置了3秒的超时时间。如果任务在3秒内没有完成，

context

将被取消，

longRunningTask

会收到取消信号并退出。注意

defer cancel()

，这是一个好习惯，即使任务提前完成，也应该调用

cancel

释放资源。

一键职达

AI全自动批量代投简历软件，自动浏览招聘网站从海量职位中用AI匹配职位并完成投递的全自动操作，真正实现'一键职达'的便捷体验。

下载

如何在Context中传递请求相关的值？

context.WithValue

函数允许你在

context

中存储键值对。这些值可以在goroutine之间传递，例如请求ID、用户信息等。

package main

import (
    "context"
    "fmt"
)

func processRequest(ctx context.Context) {
    userID := ctx.Value("userID")
    fmt.Printf("处理请求，用户ID: %v\n", userID)
}

func main() {
    ctx := context.WithValue(context.Background(), "userID", "12345")
    processRequest(ctx)
}

在这个例子中，我们在

context

中存储了

userID

。

processRequest

函数可以从

context

中获取

userID

并使用它。需要注意的是，

context.Value

的键应该是可比较的类型，通常是自定义类型，以避免与其他包冲突。此外，不要在

context

中传递可选参数，应该使用函数参数来传递。

Context的父子关系是如何工作的？

context

可以有父子关系。子

context

继承父

context

的值、截止时间和取消信号。如果父

context

被取消，所有子

context

也会被取消。

package main

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

func childTask(ctx context.Context) {
    select {
    case <-ctx.Done():
        fmt.Println("子任务被取消")
    case <-time.After(2 * time.Second):
        fmt.Println("子任务完成")
    }
}

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

    go childTask(ctx)

    time.Sleep(1 * time.Second)
    fmt.Println("取消父任务")
    cancel()

    time.Sleep(1 * time.Second) // 等待子任务退出
}

在这个例子中，