Go 中的 goroutine 之间没有父与子的关系，也就没有所谓子进程退出后的通知机制，多个 goroutine 都是平行的被调度，多个 goroutine 如何协作工作涉及通信、同步、通知和退出四个方面。

通信：chan 通道当然是 goroutine 之间通信的基础，注意这里的通信主要是指程序的数据通道。

同步：不带缓冲的 chan 提供了一个天然的同步等待机制；当然 sync.WaitGroup 也为多个 goroutine 协同工作提供一种同步等待机制。

通知：这个通知和上面通信的数据不一样，通知通常不是业务数据，而是管理、控制流数据。

退出：goroutine 之间没有父子关系，可以通过增加一个单独的通道，借助通道和 select 的广播机制实现退出。

Context 的设计目的

context 库的设计目的就是跟踪 goroutine 调用树，并在这些 goroutine 调用树中传递通知和元数据。两个目的：

退出通知机制——通知可以传递给整个 goroutine 调用树上的每一个 goroutine。
传递数据——数据可以传递给整个 goroutine 调用树上的每一个 goroutine。

基本数据结构

接口

Context

Context 是一个基本接口，所有的 Context 对象都要实现该接口，context 的使用者在调用接口都使用 Context 作为参数类型。

type Context interface {
    // 如果 Context 实现了超时控制，则该方法返回 ok true，deadline 为超时时间，否则 ok 为false
    Deadline()

    // 后端被调的 goroutine 应该监听该方法返回的 chan，以便及时释放资源。
    Done() <-chan struct {}

    // Done() 返回的 chan 收到通知的时候，才可以访问 Err() 获知因为什么原因被取消
    Err() error

    // 可以访问上游 goroutine 传递给下游 goroutine 的值
    Value(key interface{}) interface{}
}

canceler

canceler 接口是一个拓展接口，规定了取消通知的 Context 具体类型需要实现的接口。context 包中的具体类型 *cancelCtx 和 *timerCtx 都实现了该接口。

// 一个 context 对象如果实现了 canceler 接口，则可以被取消。

type canceler interface {
    // 创建 cancel 接口实例的 goroutine 调用 cancel 方法通知后续创建的 goroutine 退出
    cancel(removeFromParent bool, err error)
    
    // Done 方法返回的 chan 需要后端监听，并及时退出
    Done() <-chan struct
}

结构体

empty Context

emptyCtx 实现了 Context 接口，但不具备任何功能，因为其所有的方法都是空实现。其存在的目的是作为 Context 对象树的根（root 节点）。因为 context 包的使用思路就是不停的调用 context 包提供的包装函数来创建具有特殊功能的 Context 实例，每一个 Context 实例的创建都以上一个 Context 对象为参数，最终形成一个树状的结构。

// emptyCtx 实现了 Context 接口
type emptyCtx int

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 interface{}) interface{} {
    return nil
}

func (e *emptyCtx) String() string {
    switch e {
        case background:
            return "context.Background"
        case todo:
            return "context.TODO"
    }
    return "unknow empty Context"
}

package 定义了两个全局变量和两个封装函数，返回两个 emptyCtx 实例对象，实际使用时通过调用这两个封装函数来构造 Context 的 root 节点。

var (
    background = new(emptyCtx)
    todo = new(emptyCtx)
)

func Background() Context {
    return background
}

func TODO() Context {
    return todo
}

cancelCtx

cnacelCtx 是一个实现了 Context 接口的具体类型，同时实现了 conceler 接口。conceler 具有退出通知方法。注意退出通知机制不但能通知自己，也能逐层通知其 children 节点。

type cancelCtx struct {
    Context

    done chan struct{}

    mu sync.Mutex
    children map[canceler]bool
    err error
}

func (c *cancelCtx) Done() <-chan struct{} {
    return c.done
}

func (c *cancelCtx) Err() error {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.err
}

func (c *cancelCtx) String string {
    return fmt.Sprintf("%v.WithCancel", c.Cointext)
}

func (c *cancelCtx) cancel(removeFromParent bool, err error) {
	if err == nil {
		panic("context: internal error: missing cancel error")
	}
	c.mu.Lock()
	if c.err != nil {
		c.mu.Unlock()
		return // already canceled
	}
	c.err = err
    // 显示通知自己
	if c.done == nil {
		c.done = closedchan
	} else {
		close(c.done)
	}
    // 循环调用 childern 的 cancel 函数，由于 parent 已经取消，所以此时 child 调用 cancel 传入的是 false
	for child := range c.children {
		// NOTE: acquiring the child's lock while holding parent's lock.
		child.cancel(false, err)
	}
	c.children = nil
	c.mu.Unlock()

	if removeFromParent {
		removeChild(c.Context, c)
	}
}

timerCtx

timerCtx 是一个实现了 Context 接口的具体类型，内部封装了 cancelCtx 类型实例，同时拥有一个 deadline 变量，用来实现定时退出通知。

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

	deadline time.Time
}

func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
	return c.deadline, true
}

func (c *timerCtx) String() string {
	return contextName(c.cancelCtx.Context) + ".WithDeadline(" +
		c.deadline.String() + " [" +
		time.Until(c.deadline).String() + "])"
}

func (c *timerCtx) cancel(removeFromParent bool, err error) {
	c.cancelCtx.cancel(false, err)
	if removeFromParent {
		// Remove this timerCtx from its parent cancelCtx's children.
		removeChild(c.cancelCtx.Context, c)
	}
	c.mu.Lock()
	if c.timer != nil {
		c.timer.Stop()
		c.timer = nil
	}
	c.mu.Unlock()
}

valueCtx

valueCtx 是一个实现了 Context 接口的具体类型，内部封装了 Context 接口类型，同时封装了一个 k/v 的储存变量。valueCtx 可用来传递通知信息。

type valueCtx struct {
	Context
	key, val interface{}
}

// stringify tries a bit to stringify v, without using fmt, since we don't
// want context depending on the unicode tables. This is only used by
// *valueCtx.String().
func stringify(v interface{}) string {
	switch s := v.(type) {
	case stringer:
		return s.String()
	case string:
		return s
	}
	return "<not Stringer>"
}

func (c *valueCtx) String() string {
	return contextName(c.Context) + ".WithValue(type " +
		reflectlite.TypeOf(c.key).String() +
		", val " + stringify(c.val) + ")"
}

func (c *valueCtx) Value(key interface{}) interface{} {
	if c.key == key {
		return c.val
	}
	return c.Context.Value(key)
}

API 函数

下面两个函数是构造 Context 取消树的根节点对象，根节点对象用作后续 With 包装函数的实参。

func Background() Context
func TODO() COntext

With 包装函数用来构建不同功能的 Context 具体对象。

创建一个带有退出通知的 Context 具体对象，内部创建一个 cancelCtx 的类型实例。

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

创建一个带有超时通知的 Context 具体对象，内部创建一个 timerCtx 的类型实例。

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)

创建一个带有超时通知的 Context 具体对象，内部创建一个 timerCtx 的类型实例。

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

创建一个能够传递数据的 Context 具体对象，内部创建一个 valueCtx 的类型实例。

func WithValue(parent Context, key, val interface{}) Context

这些函数都有一个共同特点——parent 参数，其实这就是实现 Context 通知树的必备条件。在 goroutine 的调用链中，Context 的实例被逐层的包装并传递，每层又可以对传进来的 Context 实例再封装自己所需的功能，整个调用树需要一个数据结构来维护，这个维护逻辑在这些包装函数的内部实现。

使用 context 传递数据的争议

该不该使用 context 传递数据

首先要清楚使用 context 包主要是解决 goroutine 的通知退出，传递数据是其一个额外功能。可以在使用它传递一些元信息，总之使用 context 传递的信息不能影响正常的业务流程，程序不要期待在 context 中传递一些必须的参数等，没有这些参数，程序也应该能正常工作。

在 context 中传递数据的坏处

传递的都是 interface{} 类型的值，编译器不能进行严格的类型校验。
从 interface{} 到具体类型需要使用类型断言和接口查询，有一定的运行期开销和性能损失。
值在传递过程中有可能被后续的服务覆盖，且不易被发现。
传递信息不简明，较晦涩；不能通过代码文档一眼看到传递的是什么，不利于后续维护。

context 应当传递什么参数

日志信息
调试信息
不影响业务主逻辑的可选数据

context 包提供的核心的功能是多个 goroutine 之间的退出通知机制，传递数据只是一个辅助功能，应谨慎使用 context 传递数据。

Tsubasa 的日记

👉标签