当进行 Goroutine 编程时，Go 语言中的 Context（上下文）是一个非常重要的概念。它可以用于在不同的 Goroutine 之间传递请求特定值、取消信号以及超时截止日期等数据，以协调 Goroutine 之间的操作。
在本文中，我们将深入介绍 Go 语言中的各种 context，包括它们的含义、区别以及最佳实践。
Context 的含义
Context 是 Go 语言中的一个接口类型，它定义了在 Goroutine 之间传递请求相关数据的方法。Context 接口类型的定义如下：
type Context interface {
// 返回与此上下文关联的取消函数。
Done() <-chan struct{}
// 返回此上下文的截止时间（如果有）。
// 如果没有截止时间，则ok为false。
Deadline() (deadline time.Time, ok bool)
// 返回此上下文的键值对数据。
Value(key interface{}) interface{}
}
Context 接口包含三个方法：
-
Done()方法返回一个只读的 channel，当 context 被取消或者超时截止日期到达时，该 channel 会被关闭。当接收到该 channel 关闭的信号时，就意味着该 context 被取消。 -
Deadline()方法返回 context 的超时截止日期，如果没有设置超时截止日期，则返回false。当时间达到超时截止日期时，context 会自动被取消。 -
Value()方法用于在 context 中存储和获取键值对数据。该方法是非线程安全的。
Context 的类型
Go 语言中常用的 Context 类型有以下几种
-
context.Background()Background context 是 Context 接口的一个默认实现，它没有任何值，也不会被取消。当没有更合适的 context 实例时，可以使用 background context。 -
context.TODO()TODO context 是 Context 接口的一个默认实现，它和 background context 类似，但是它是一个标记未完成工作的 context，用于暂时占位，待后续替换为真正的 context 实例。 -
context.WithCancel(parent)WithCancel 函数可以派生一个子 context，同时返回一个取消函数，用于在需要的时候取消该 context。当父 context 被取消或者取消函数被调用时，子 context 也会被取消。 -
context.WithDeadline(parent, deadline)WithDeadline 函数可以派生一个子 context，同时返回一个取消函数，用于在需要的时候取消该 context。与 WithCancel 不同的是，WithDeadline 可以设置一个超时截止日期，当截止日期到达时，子 context 会自动被取消。 -
context.WithTimeout(parent, timeout)WithTimeout 函数是 WithDeadline 的一个特例，它也可以派生一个子 context，并设置超时时间。与 WithDeadline 不同的是，WithTimeout 可以设置一个相对于超时任务，使用 WithTimeout 更为常见。 -
context.WithValue(parent, key, val)WithValue 函数可以派生一个子 context，并在其中存储键值对数据。该方法不是线程安全的，因此在并发环境下使用时需要注意。
Context 的最佳实践
在使用 Context 时，需要遵循以下最佳实践：
- 在函数参数中添加一个 context 参数，以便于 Goroutine 可以获取到该 context。
- 如果一个 Goroutine 创建了多个子 Goroutine，那么应该将相同的 context 实例传递给所有子 Goroutine。
- 当一个 context 被取消时，它派生的所有子 context 也应该被取消。
- 当一个 context 被取消时，其关联的资源（如数据库连接、文件描述符等）应该被释放。
- 当使用 WithDeadline 和 WithTimeout 时，应该考虑到超时时间是否合理，过短的超时时间会导致任务失败，过长的超时时间会浪费资源。
总结
在 Goroutine 编程中，Context 是非常重要的概念。它可以用于在不同的 Goroutine 之间传递请求特定值、取消信号以及超时截止日期等数据，以协调 Goroutine 之间的操作。Go 语言中常用的 Context 类型有：Background、TODO、WithCancel、WithDeadline、WithTimeout 和 WithValue。在使用 Context 时，需要遵循一些最佳实践，以确保程序的正确性和健壮性。
示例 1：使用 WithCancel 实现 Goroutine 的取消
package main
import (
"context"
"fmt"
"time"
)
func worker(ctx context.Context, id int) {
for {
select {
default:
fmt.Printf("worker %d is running\n", id)
case <-ctx.Done():
fmt.Printf("worker %d is cancelled\n", id)
return
}
}
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
// 启动两个 worker
go worker(ctx, 1)
go worker(ctx, 2)
// 运行一段时间后取消所有 worker
time.Sleep(time.Second * 3)
cancel()
time.Sleep(time.Second)
}
上述代码中，我们通过使用 WithCancel 派生了一个新的 context，并将其传递给了两个 Goroutine。在 main 函数中，我们等待 3 秒钟后取消了所有的 Goroutine。在 worker 函数中，我们使用 select 语句来监听 ctx.Done() 信号，如果 ctx 被取消，我们就结束 Goroutine 的执行。
示例 2：使用 WithTimeout 实现超时任务
package main
import (
"context"
"fmt"
"time"
)
func worker(ctx context.Context) {
select {
case <-time.After(time.Second * 2):
fmt.Println("worker completed")
case <-ctx.Done():
fmt.Println("worker cancelled")
}
}
func main() {
ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
defer cancel()
go worker(ctx)
select {
case <-ctx.Done():
fmt.Println("main cancelled")
case <-time.After(time.Second * 4):
fmt.Println("main completed")
}
}
上述代码中，我们使用 WithTimeout 派生了一个新的 context，并将其传递给了一个 Goroutine。在 worker 函数中，我们使用 select 语句监听两个 channel，一是通过 time.After 函数模拟 2 秒钟的工作，另一个是 ctx.Done() 信号。如果 ctx 被取消，我们就结束 Goroutine 的执行。在 main 函数中，我们使用 select 语句监听两个 channel，一个是 ctx.Done() 信号，一个是通过 time.After 函数模拟 4 秒钟的执行时间。这样，如果 worker Goroutine 能在 3 秒钟之内完成工作，程序就会输出 "main completed"，否则程序就会输出 "main cancelled"。
示例 3：使用 WithValue 存储请求特定的值
package main
import (
"context"
"fmt"
)
type key int
const nameKey key = 0
func worker(ctx context.Context) {
if name, ok := ctx.Value(nameKey).(string); ok {
fmt.Printf("worker: hello, %s!\n", name)
} else {
fmt.Println("worker: no name found")
}
}
func main() {
ctx := context.WithValue(context.Background(), nameKey, "Alice")
go worker(ctx)
// 等待一段时间，以便让 worker 完成工作
fmt.Scanln()
}
上述代码中，我们使用 WithValue 函数在 context 中存储了一个值。在 worker 函数中，我们通过 ctx.Value 函数来获取这个值，并将其作为字符串类型打印出来。在 main 函数中，我们使用 fmt.Scanln 函数等待用户的输入，以便让程序保持运行状态，直到 worker Goroutine 完成工作。
示例 4：使用 WithDeadline 设置任务的截止时间
package main
import (
"context"
"fmt"
"time"
)
func worker(ctx context.Context) {
deadline, ok := ctx.Deadline()
if ok {
fmt.Printf("worker: deadline set to %s\n", deadline.Format(time.RFC3339))
}
select {
case <-time.After(time.Second * 2):
fmt.Println("worker completed")
case <-ctx.Done():
fmt.Println("worker cancelled")
}
}
func main() {
d := time.Now().Add(time.Second * 3)
ctx, cancel := context.WithDeadline(context.Background(), d)
defer cancel()
go worker(ctx)
select {
case <-ctx.Done():
fmt.Println("main cancelled")
case <-time.After(time.Second * 4):
fmt.Println("main completed")
}
}
上述代码中，我们使用 WithDeadline 派生了一个新的 context，并将其传递给了一个 Goroutine。在 worker 函数中，我们使用 ctx.Deadline 函数获取任务的截止时间，并将其格式化后打印出来。在 select 语句中，我们使用 time.After 函数模拟了 2 秒钟的工作，另一个是 ctx.Done() 信号。如果 ctx 被取消，我们就结束 Goroutine 的执行。在 main 函数中，我们使用 select 语句监听两个 channel，一个是 ctx.Done() 信号，一个是通过 time.After 函数模拟 4 秒钟的执行时间。这样，如果 worker Goroutine 能在 3 秒钟之内完成工作，程序就会输出 "main completed"，否则程序就会输出 "main cancelled"。
这些示例代码演示了不同类型的 Context 的用法，它们都有自己的特点和适用场景。在实际的开发过程中，我们需要根据具体情况来选择使用哪种类型的 Context，并且在 Goroutine 中使用 Context 时，要遵循一些最佳实践，比如：
- 在每个 Goroutine 的入口处创建一个新的 Context 对象，并将其传递给下一级函数或者 Goroutine；
- 在 Goroutine 中使用 select 语句监听 ctx.Done() 信号，如果收到该信号，应该尽快结束 Goroutine 的执行；
- 在使用 Context 时要注意线程安全性，避免出现竞态条件或者数据竞争的情况。
总之，Context 是 Go 语言中非常重要的一个概念，它可以帮助我们实现 Goroutine 的取消、超时、请求特定的值等功能，同时还能避免出现 Goroutine 泄漏等问题。因此，在实际的开发过程中，我们需要充分了解并熟练掌握 Context 的使用方法，以便在编写高并发的应用程序时，能够更好地利用 Goroutine 来提高程序的性能和响应速度。
希望本篇文章能够对您了解和掌握 Go 语言中的 Context 有所帮助。如果您有任何疑问或者建议，欢迎在评论区留言。
