golang中context使用总结

一、context使用注意事项

在使用context时，有一些需要注意的事项，以及一些与性能优化相关的建议：

1. 避免滥用context传递数据：context的主要目的是传递请求范围的数据和取消信号，而不是用于传递全局状态或大量数据。滥用context传递大量数据可能导致上下文对象变得臃肿，增加内存和GC压力。

2. 不要修改已传递的context：传递的context是不可变的，即使在函数内部对其调用cancel方法也不会影响调用方的context。如果需要对context进行修改，应该通过返回一个新的派生context来实现。

3. 只在需要时传递context：不要将context作为函数参数无限制地传递，而是在需要时传递。这样可以避免不必要的复杂性和代码膨胀。

4. 及早检查取消信号：在使用context的地方，应该及早检查ctx.Done()的返回值，以尽早响应取消信号。在耗时操作前或可能阻塞的地方，应该通过select语句来监听多个操作，包括取消信号、超时和其他channel。

5. 使用WithCancel替代WithTimeout：在可能的情况下，优先使用WithCancel函数来设置取消信号，而不是仅仅依赖于WithTimeout函数。这样可以有更精确的控制和更灵活的处理方式。

6. 优化context的传递：在频繁调用的函数链中，避免在每个函数中重复传递相同的context，可以通过使用结构体或函数闭包将context作为参数进行传递，从而减少代码重复和提升性能。

7. 及时取消不再需要的goroutine：如果在多个goroutine中使用context，确保在不再需要时及时取消goroutine，以避免资源浪费和潜在的goroutine泄漏。

这些注意事项和性能优化建议可帮助确保正确且高效地使用context，避免滥用和性能问题。根据具体场景和需求，可以灵活使用context的机制来优化代码的可读性、并发安全性和性能。

二、context使用举例

在Go语言中，context（上下文）是在不同goroutine之间传递请求范围数据、取消信号和超时处理的一种机制。下面详细介绍context的每种使用情况和相应的代码举例：

1. 传递请求范围数据：

   package main
   
   import (
   	"context"
   	"fmt"
   )
   
   // 定义一个键类型（key）用于context中的数据传递
   type key string
   
   // 在context中设置数据
   func withValue(ctx context.Context) {
   	// 使用WithValue将数据存储在context中
   	ctxWithData := context.WithValue(ctx, key("name"), "John")
   
   	// 调用另一个函数，并将带有数据的context传递给它
   	printName(ctxWithData)
   }
   
   // 从context中获取并使用数据
   func printName(ctx context.Context) {
   	// 从context中获取数据，并进行类型断言
   	if name, ok := ctx.Value(key("name")).(string); ok {
   		fmt.Println("Name:", name)
   	}
   }
   
   func main() {
   	// 创建根context
   	ctx := context.Background()
   
   	// 传递context并设置数据
   	withValue(ctx)
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34

   在上面的示例中，我们定义了一个key类型，用于在context中存储数据。然后，我们使用WithValue函数将数据存储在带有数据的context ctxWithData 中，并将其传递给printName函数。在printName函数中，我们使用Value方法从context中获取数据，并进行类型断言后打印出来。

2. 取消信号：

   package main
   
   import (
   	"context"
   	"fmt"
   	"time"
   )
   
   // 模拟一些耗时操作
   func performTask(ctx context.Context) {
   	// 检查是否接收到取消信号
   	select {
   	case <-ctx.Done():
   		fmt.Println("Task canceled")
   		return
   	default:
   		// 模拟长时间运行的任务
   		time.Sleep(5 * time.Second)
   		fmt.Println("Task completed")
   	}
   }
   
   func main() {
   	// 创建根context
   	ctx := context.Background()
   
   	// 派生子context，并设置取消信号
   	ctx, cancel := context.WithCancel(ctx)
   
   	// 启动耗时操作的goroutine，并传递带有取消信号的context
   	go performTask(ctx)
   
   	// 模拟一些操作后取消任务
   	time.Sleep(2 * time.Second)
   	cancel() // 发送取消信号
   
   	// 等待一段时间，确保程序有足够的时间处理取消信号
   	time.Sleep(1 * time.Second)
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39

   在上面的示例中，我们创建了一个任务函数performTask，该函数会检查是否接收到取消信号。使用context.WithCancel函数创建派生的子context，并通过调用返回的cancel函数发送取消信号。然后，我们在一个goroutine中运行任务函数，并通过传递带有取消信号的context来监听取消信号。在主goroutine中，我们等待一段时间后调用cancel函数发送取消信号。当任务函数接收到取消信号后，它会打印"Task canceled"。

3. 超时处理：

   package main
   
   import (
   	"context"
   	"fmt"
   	"time"
   )
   
   // 模拟一些耗时操作
   func performTask(ctx context.Context) {
   	// 检查是否接收到取消信号或超时
   	select {
   	case <-ctx.Done():
   		fmt.Println("Task canceled")
   	case <-time.After(5 * time.Second):
   		fmt.Println("Task completed")
   	}
   }
   
   func main() {
   	// 创建根context
   	ctx := context.Background()
   
   	// 派生子context，并设置超时时间
   	ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
   	defer cancel()
   
   	// 启动耗时操作的goroutine，并传递带有超时设置的context
   	go performTask(ctx)
   
   	// 等待一段时间，确保程序有足够的时间处理超时或取消信号
   	time.Sleep(5 * time.Second)
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33

   在上面的示例中，我们创建了一个任务函数performTask，该函数会检查是否接收到取消信号或超时。使用context.WithTimeout函数创建派生的子context，并通过调用返回的cancel函数来设置超时时间。然后，我们在一个goroutine中运行任务函数，并传递带有超时设置的context来监听超时或取消信号。在主goroutine中，我们等待一段时间以确保程序有足够的时间处理超时或取消信号。当超过超时时间后，任务函数会打印"Task canceled"。

这些是context在Go语言中的常见用法，它们使得在并发环境中处理请求范围数据、取消信号和超时变得更加简单和可靠。根据具体的使用场景，你可以选择适当的context函数来创建和传递context，并根据需要进行取消和超时处理。