引言

之前对context的了解比较浅薄，只知道它是用来传递上下文信息的对象；

对于Context本身的存储、类型认识比较少。

最近又正好在业务代码中发现一种用法：在每个协程中都会复制一份新的局部context对象，想探究下这种写法在性能上有没有弊端。

jobList := []func() error{
		s.task1,
		s.task2,
		s.task3,
		s.task4,
	}
if err := gconc.GConcurrency(jobList); err != nil {
    resource.LoggerService.Error(ctx, "exec concurrency job list error", logit.Error("error", err))
}

func (s *Service) task1() (err error) {
	if !s.isLogin() {
		return nil
	}
    // 新局部变量，值来自全局的context对象
	ctx := s.ctx
	return nil
}

基本概念

介绍

golang.org/x/net/context，是golang中的一个标准库，主要作用就是创建一个上下文，实现对程序中创建的协程通过传递上下文信息来实现对协程的管理。

创建一个Context对象

在Go语言中，可以通过多种方式创建Context：

空Context对象

Background()和TODO()：这两个函数分别用于创建空的Context，通常作为根节点使用

• Background()通常用于main函数、初始化以及测试；
• TODO()则用于尚未确定使用哪种Context的情况。

可取消的Contex对象

WithCancel(parent Context)：创建一个可取消的Context，并返回一个取消函数

• 当调用取消函数时，会通知所有的子Context，使它们都取消执行。

带有截止时间的Context对象

WithDeadline(parent Context, deadline time.Time)：创建一个带有截止时间的Context，并返回一个取消函数

• 当超过截止时间时，会自动通知所有的子Context，使它们都取消执行；
• 当超过截止时间时，会自动通知所有的子Context，使它们都取消执行。

带有超时控制的Contex对象

WithTimeout(parent Context, timeout time.Duration)：创建一个带有超时控制的Context，它等同于WithDeadline(parent, time.Now().Add(timeout))。

带键值对的Context对象

WithValue(parent Context, key, val interface{})：创建一个带有键值对的Context，同时保留父级Context的所有数据。

• 需要注意Context主要用于传递请求范围的数据，而不是用于存储大量数据或传递业务逻辑中的参数。

分析Context对象

上面介绍了几种创建Context对象的方法，包括创建可取消的Context、带有截止时间的Context以及带有键值对的Context

Context接口

type Context interface {
	Deadline() (deadline time.Time, ok bool)

	Done() <-chan struct{}

	Err() error
    
	Value(key any) any
}

Context接口定义了四个方法：

1. Deadline()：返回该context被取消的时间，当没有设置截止日期时，返回ok==false。
2. Done()：返回一个只读的channel。当context被取消或超时时，此channel会被关闭，通知goroutine不再继续执行。
3. Err()：如果Done尚未关闭，返回nil；如果context已被取消或超时，返回取消或超时的错误。
4. Value(key interface{}) interface{}：从context中获取与key相关联的值。通常用于传递一些请求范围内的变量，如用户认证信息、跟踪请求ID等。但需要注意的是，不应滥用此功能传递业务逻辑中的参数。

不同类型的Context

通过分析Context接口，可以知道Context对象都是对Context接口的实现，如空Context对象就是emptyCtx，它不包含任何值

type emptyCtx struct{}

func (emptyCtx) Deadline() (deadline time.Time, ok bool) {
	return
}

func (emptyCtx) Done() <-chan struct{} {
	return nil
}

func (emptyCtx) Err() error {
	return nil
}

func (emptyCtx) Value(key any) any {
	return nil
}

而带有超时控制的Context其实就是一个带有定时器并且实现了Context接口的对象

type timerCtx struct {
	cancelCtx
	timer *time.Timer // Under cancelCtx.mu.

	deadline time.Time
}

Context的作用

控制子协程

对于存在若干个协程的程序，协程之前可能会存在如下的关系，这就需要在父协程关闭时，对子协程及时关闭；

否则协程可能会持续存在与内存中，造成内存泄漏。

Context对子协程的控制销毁就是基于协程创建的过程中，为每个子协程创建子context，以WithCancel()方法为例进行分析：

WithCancel()会返回一个新的子context和一个上下文取消方法，当执行cancel时，当前协程下的子context都会被销毁。

package main
 
import (
	"context"
	"fmt"
	"time"
)
 
// worker 是一个模拟工作的函数，它接受一个 context 并根据 context 的状态来决定是否继续工作。
func worker(ctx context.Context, id int) {
	for {
		select {
		case <-ctx.Done():
			// 当 context 被取消时，worker 会收到通知并退出循环。
			fmt.Printf("Worker %d: stopping\n", id)
			return
		default:
			// 继续执行模拟的工作。
			fmt.Printf("Worker %d: working\n", id)
			time.Sleep(1 * time.Second)
		}
	}
}
 
func main() {
	// 创建一个带取消功能的 context。
	ctx, cancel := context.WithCancel(context.Background())
 
	// 启动多个 worker 协程。
	for i := 1; i <= 3; i++ {
		go worker(ctx, i)
	}
 
	// 让主协程等待一段时间，然后取消 context。
	time.Sleep(5 * time.Second)
	fmt.Println("Main: canceling context")
	cancel()
 
	// 等待一段时间以确保所有 worker 都有机会响应取消信号。
	// 在实际应用中，你可能需要一个更复杂的机制来等待所有 worker 退出。
	time.Sleep(2 * time.Second)
	fmt.Println("Main: exiting")
}

传递上下文信息

通常使用带键值对的Contex对象，即ValueContext传递信息。

package main

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

// requestIDKey 是一个用于在 context 中存储请求 ID 的键。
type requestIDKey struct{}

// worker 是一个模拟工作的函数，它接受一个 context 并从中提取请求 ID。
func worker(ctx context.Context, taskName string) {
	// 从 context 中获取请求 ID。
	requestID := ctx.Value(requestIDKey{}).(string)
	fmt.Printf("%s: started, request ID: %s\n", taskName, requestID)

	// 模拟工作。
	time.Sleep(2 * time.Second)

	// 完成工作。
	fmt.Printf("%s: completed, request ID: %s\n", taskName, requestID)
}

func main() {
	// 创建一个带有请求 ID 的 context。
	requestID := "12345"
	ctx := context.WithValue(context.Background(), requestIDKey{}, requestID)

	// 启动多个 worker 协程。
	tasks := []string{"Task A", "Task B", "Task C"}
	for _, task := range tasks {
		go worker(ctx, task)
	}

	// 等待一段时间以确保所有 worker 都有机会完成工作。
	// 在实际应用中，你可能需要一个更复杂的机制来等待所有 worker 退出。
	time.Sleep(6 * time.Second)
	fmt.Println("Main: all tasks completed or timed out")
}

额外补充：Context变量的复制

写一个示例代码，通过debug来分析

type UserInfo struct {
	UID     int
	Name    string
	Address *Address
}
type Address struct {
	X int
	Y int
}

func TestValueContext(t *testing.T) {
	ctx := context.Background()
	address := &Address{
		X: 101,
		Y: 202,
	}
	withValue := context.WithValue(ctx, UserInfo{}, UserInfo{
		UID:     1,
		Name:    "test",
		Address: address,
	})
    // 新变量 拷贝的context对象
	copyCtx := withValue
	fmt.Println(copyCtx)
}

通过debug可以看到，和普通的变量赋值一样，拷贝出的copyCtx对象就是ctx对象的值；

拷贝的过程是浅拷贝，当ctx中包含指针时，拷贝的是其地址。

最开始的问题-拷贝Context的意义？

通过上面的分析我们可以知道以下几点事实

1. Context的拷贝是针对具体实现了Context接口的对象，因为接口无法拷贝；
2. Context对象的拷贝是浅拷贝，和普通的变量一样；
3. 需要基于一个Context实现 添加信息、并发控制、并发安全等功能，需要使用Context库提供的方法，普通的拷贝没有意义。

因此，问题代码中对ctx的拷贝，不考虑代码清晰度的情况下，并没有额外的意义，而且在被拷贝的Context对象很大时，会有额外的内存开销。

func (s *Service) task1() (err error) {
	if !s.isLogin() {
		return nil
	}
    // 新局部变量，值来自全局的context对象
	ctx := s.ctx
	return nil
}

参考

Go语言高并发系列三：context - 掘金