Go语言context使用方法详解

在Go语言中，context 包用于管理请求的生命周期、取消信号、超时以及跨API边界传递请求范围的值。context 在并发编程中非常有用，尤其是在处理HTTP请求、数据库操作等需要控制超时和取消的场景。

1. 创建Context

1.1 `context.Background()`

context.Background() 返回一个空的 Context，通常作为根 Context 使用。

ctx := context.Background()

1.2 `context.TODO()`

context.TODO() 也是一个空的 Context，通常在不清楚使用哪个 Context 时使用。它和 context.Background() 类似，但语义上表示“待定”。

ctx := context.TODO()

2. 派生Context

2.1 `context.WithCancel()`

context.WithCancel() 返回一个派生 Context 和一个取消函数。调用取消函数会取消该 Context 及其派生 Context。

ctx, cancel := context.WithCancel(context.Background())
defer cancel() // 确保在函数退出时取消Context

// 在需要取消时调用 cancel()

2.2 `context.WithTimeout()`

context.WithTimeout() 返回一个派生 Context，并在指定的超时时间后自动取消。

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

// 2秒后Context会自动取消

2.3 `context.WithDeadline()`

context.WithDeadline() 返回一个派生 Context，并在指定的截止时间自动取消。

deadline := time.Now().Add(2 * time.Second)
ctx, cancel := context.WithDeadline(context.Background(), deadline)
defer cancel()

// 在deadline时间到达时，Context会自动取消

2.4 `context.WithValue()`

context.WithValue() 返回一个派生 Context，并携带一个键值对。这个键值对可以在 Context 的整个生命周期中传递。

ctx := context.WithValue(context.Background(), "userID", 123)

// 获取值
userID := ctx.Value("userID").(int)

3. 使用Context

3.1 传递Context

Context 通常作为函数的第一个参数传递，尤其是在处理请求、数据库操作等需要控制超时和取消的场景。

func process(ctx context.Context) {
    select {
    case <-time.After(1 * time.Second):
        fmt.Println("Processing completed")
    case <-ctx.Done():
        fmt.Println("Processing cancelled:", ctx.Err())
    }
}

3.2 检查Context是否取消

可以通过 ctx.Done() 来检查 Context 是否被取消或超时。

select {
case <-ctx.Done():
    fmt.Println("Context cancelled:", ctx.Err())
default:
    fmt.Println("Context is still active")
}

4. 示例

package main

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

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    go process(ctx)

    time.Sleep(3 * time.Second)
}

func process(ctx context.Context) {
    select {
    case <-time.After(1 * time.Second):
        fmt.Println("Processing completed")
    case <-ctx.Done():
        fmt.Println("Processing cancelled:", ctx.Err())
    }
}

在这个示例中，process 函数会在1秒后完成，但由于 Context 的超时时间为2秒，因此 process 会正常完成。如果将 time.After 的时间改为3秒，process 函数会因为 Context 超时而被取消。

5. 注意事项

context.Background() 和 context.TODO() 都是空的 Context，但语义上有所不同。
context.WithValue() 应该谨慎使用，避免滥用。通常只用于传递请求范围的值，而不是传递函数的参数。
Context 是不可变的，每次派生都会返回一个新的 Context。

通过合理使用 context，可以有效地管理Go程序中的并发操作，避免资源泄漏和超时问题。

示例

为了更清晰地解释 context 的作用，通过一个具体的示例来展示它的使用场景。这个示例模拟了一个常见的场景：处理一个HTTP请求，并在请求中执行一个耗时的操作（如数据库查询），同时支持超时和取消。

示例场景

假设我们有一个HTTP服务，客户端发送请求后，服务端需要执行一个耗时的任务（比如查询数据库）。如果任务执行时间过长，我们希望能够在超时后自动取消任务，或者允许客户端主动取消请求。

代码实现

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
)

func main() {
	// 启动HTTP服务
	http.HandleFunc("/process", handleProcess)
	fmt.Println("Server started at :8080")
	http.ListenAndServe(":8080", nil)
}

// 处理HTTP请求
func handleProcess(w http.ResponseWriter, r *http.Request) {
	// 创建一个带有超时的Context，超时时间为2秒
	ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
	defer cancel() // 确保在函数退出时取消Context

	// 模拟一个耗时的任务
	resultCh := make(chan string)
	go doSomething(ctx, resultCh)

	// 等待任务完成或超时
	select {
	case result := <-resultCh:
		// 任务完成，返回结果
		fmt.Fprintln(w, result)
	case <-ctx.Done():
		// 任务超时或被取消
		fmt.Fprintln(w, "Request cancelled or timed out:", ctx.Err())
	}
}

// 模拟一个耗时的任务
func doSomething(ctx context.Context, resultCh chan<- string) {
	// 模拟一个耗时操作（比如数据库查询）
	time.Sleep(3 * time.Second) // 假设任务需要3秒完成

	// 检查Context是否被取消
	select {
	case <-ctx.Done():
		// 如果Context被取消，直接返回
		fmt.Println("Task cancelled:", ctx.Err())
		return
	default:
		// 任务完成，发送结果
		resultCh <- "Task completed successfully!"
	}
}

代码解析

context.WithTimeout:
- 我们使用 context.WithTimeout 创建了一个带有2秒超时的 Context。
- 如果任务在2秒内没有完成，Context 会自动取消。
ctx.Done():
- ctx.Done() 返回一个通道，当 Context 被取消或超时时，该通道会关闭。
- 我们可以通过监听这个通道来判断任务是否需要取消。
doSomething 函数:
- 这是一个模拟的耗时任务，假设需要3秒完成。
- 在任务执行过程中，会检查 ctx.Done()，如果 Context 被取消，任务会提前退出。
select 语句:
- 在 handleProcess 中，我们使用 select 语句同时监听任务结果和 Context 的取消信号。
- 如果任务在2秒内完成，返回结果；如果超时或被取消，返回错误信息。

运行结果

任务超时:
- 由于任务需要3秒完成，而 Context 的超时时间为2秒，任务会被取消。
- 客户端会收到响应：Request cancelled or timed out: context deadline exceeded。
任务完成:
- 如果将 time.Sleep(3 * time.Second) 改为 time.Sleep(1 * time.Second)，任务会在2秒内完成。
- 客户端会收到响应：Task completed successfully!。
客户端主动取消请求:
- 如果客户端在任务执行过程中关闭连接（比如关闭浏览器），Context 会被取消。
- 服务端会检测到 ctx.Done()，并提前退出任务。

`Context` 的作用总结

超时控制:
- 通过 context.WithTimeout，可以设置任务的超时时间，避免任务无限期执行。
取消信号:
- 通过 Context 的取消机制，可以通知任务提前退出，释放资源。
跨API传递值:
- 可以使用 context.WithValue 在 Context 中传递请求范围的值（如用户ID、请求ID等）。
并发控制:
- 在并发编程中，Context 可以协调多个 Goroutine 的执行，确保它们能够正确响应取消信号。

实际应用场景

HTTP请求处理：控制请求的超时和取消。
数据库操作：设置查询超时，避免长时间占用数据库连接。
微服务调用：在分布式系统中传递请求上下文（如TraceID）。
任务调度：协调多个任务的执行和取消。

context.WithTimeout 的返回值以及 ctx.Done() 的含义

1. `context.WithTimeout` 的返回值

context.WithTimeout 是 context 包中的一个函数，用于创建一个带有超时时间的 Context。它的函数签名如下：

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

返回值解析

Context:
- 这是一个派生自 parent 的新 Context。
- 这个 Context 会在指定的 timeout 时间后自动取消。
- 你可以将这个 Context 传递给其他函数或 Goroutine，用于控制它们的执行。
CancelFunc:
- 这是一个函数，调用它会立即取消 Context，而不需要等待超时时间到达。
- 通常使用 defer cancel() 来确保在函数退出时释放资源。

示例

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel() // 确保在函数退出时取消Context

ctx 是一个新的 Context，它会在2秒后自动取消。
cancel 是一个函数，调用它会立即取消 ctx。

2. `ctx.Done()` 的含义

ctx.Done() 是 Context 接口的一个方法，它的作用是返回一个只读的通道（<-chan struct{}）。这个通道用于通知 Context 的状态变化。

返回值解析

<-chan struct{}:
- 这是一个只读的通道。
- 当 Context 被取消或超时时，这个通道会被关闭。
- 你可以通过监听这个通道来判断 Context 是否被取消。

使用场景

当你需要监听 Context 的取消信号时，可以使用 ctx.Done()。
通常与 select 语句结合使用，用于同时监听多个通道（如任务结果和取消信号）。

示例

select {
case <-ctx.Done():
    // Context被取消或超时
    fmt.Println("Context cancelled:", ctx.Err())
case result := <-someChannel:
    // 任务完成
    fmt.Println("Task result:", result)
}

如果 ctx.Done() 通道被关闭，说明 Context 被取消或超时。
你可以通过 ctx.Err() 获取取消的原因（如 context.DeadlineExceeded 或 context.Canceled）。

结合示例

以下是一个完整的示例，展示 context.WithTimeout 和 ctx.Done() 的使用：

package main

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

func main() {
	// 创建一个带有2秒超时的Context
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel() // 确保在函数退出时取消Context

	// 启动一个耗时的任务
	go doSomething(ctx)

	// 等待任务完成或Context取消
	select {
	case <-ctx.Done():
		// Context被取消或超时
		fmt.Println("Main: Context cancelled:", ctx.Err())
	case <-time.After(3 * time.Second):
		// 任务完成（这里不会执行，因为Context会先超时）
		fmt.Println("Main: Task completed")
	}
}

// 模拟一个耗时的任务
func doSomething(ctx context.Context) {
	select {
	case <-time.After(3 * time.Second):
		// 任务完成
		fmt.Println("Task: Work done")
	case <-ctx.Done():
		// Context被取消或超时
		fmt.Println("Task: Context cancelled:", ctx.Err())
	}
}

运行结果

任务超时:
- 由于 Context 的超时时间为2秒，而任务需要3秒完成，ctx.Done() 通道会在2秒后关闭。
- 输出：
```
Task: Context cancelled: context deadline exceeded
Main: Context cancelled: context deadline exceeded
```
任务完成:
- 如果将 time.After(3 * time.Second) 改为 time.After(1 * time.Second)，任务会在2秒内完成。
- 输出：
```
Task: Work done
Main: Task completed
```

总结

context.WithTimeout:
- 返回一个新的 Context 和一个 CancelFunc。
- Context 会在指定的超时时间后自动取消。
- CancelFunc 用于手动取消 Context。
ctx.Done():
- 返回一个只读通道，用于监听 Context 的取消信号。
- 当 Context 被取消或超时时，通道会被关闭。

通过这两个机制，Context 可以有效地控制任务的执行，避免资源浪费和超时问题。希望这个解释能帮助你更好地理解 Context 的作用！如果还有疑问，欢迎继续提问！

posted @ 2025-01-26 09:54 guanyubo 阅读(48) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· golang面经

· golang中的sync包

· Go context 介绍

· Go-Context

· go context用法

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· .NET10 - 预览版1新功能体验（一）

历史上的今天：
2024-01-26 Reactor和Proactor
2024-01-26 Linux man命令

公告

昵称： guanyubo
园龄： 1年1个月
粉丝： 17
关注： 2

+加关注

2025年3月

日

一

二

三

四

五

六

yubo-guan

Go语言context使用方法详解

1. 创建Context

1.1 `context.Background()`

1.2 `context.TODO()`

2. 派生Context

2.1 `context.WithCancel()`

2.2 `context.WithTimeout()`

2.3 `context.WithDeadline()`

2.4 `context.WithValue()`

3. 使用Context

3.1 传递Context

3.2 检查Context是否取消

4. 示例

5. 注意事项

示例

示例场景

代码实现

代码解析

运行结果

`Context` 的作用总结

实际应用场景

context.WithTimeout 的返回值以及 ctx.Done() 的含义

1. `context.WithTimeout` 的返回值

2. `ctx.Done()` 的含义

结合示例

运行结果

总结

公告

搜索

常用链接

最新随笔

积分与排名

随笔分类 (367)

随笔档案 (355)

阅读排行榜

推荐排行榜

最新评论

yubo-guan

Go语言context使用方法详解

1. 创建Context

1.1 context.Background()

1.2 context.TODO()

2. 派生Context

2.1 context.WithCancel()

2.2 context.WithTimeout()

2.3 context.WithDeadline()

2.4 context.WithValue()

3. 使用Context

3.1 传递Context

3.2 检查Context是否取消

4. 示例

5. 注意事项

示例

示例场景

代码实现

代码解析

运行结果

Context 的作用总结

实际应用场景

context.WithTimeout 的返回值以及 ctx.Done() 的含义

1. context.WithTimeout 的返回值

2. ctx.Done() 的含义

结合示例

运行结果

总结

公告

搜索

常用链接

最新随笔

积分与排名

随笔分类 (367)

随笔档案 (355)

阅读排行榜

推荐排行榜

最新评论

1.1 `context.Background()`

1.2 `context.TODO()`

2.1 `context.WithCancel()`

2.2 `context.WithTimeout()`

2.3 `context.WithDeadline()`

2.4 `context.WithValue()`

`Context` 的作用总结

1. `context.WithTimeout` 的返回值

2. `ctx.Done()` 的含义