14_context

Never start a goroutine without knowing how it will stop。

如果你不知道协程如何退出，就不要使用它。

为什么需要Context?

安全并及时地停止协程和与协程关联的子协程，避免白白消耗资源。
在没有 Context 之前我们一般会怎么做呢？我们需要借助通道的 close 机制，这个机制会唤醒所有监听该通道的协程，并触发相应的退出逻辑。写法大致如下：
```
select {
  case <-c:
    // 业务逻辑
  case <-done:
    fmt.Println("退出协程")
}
```
为了对超时进行规范处理，在 Go 1.7 之后，Go 官方引入了 Context 来实现协程的退出。
Context 还提供了跨协程、甚至是跨服务的退出管理。
Context 本身的含义是上下文，我们可以理解为它内部携带了超时信息、退出信号，以及其他一些上下文相关的值（例如携带本次请求中上下游的唯一标识 trace_id）。由于 Context 携带了上下文信息，父子协程就可以“联动”了。

级联退出

如下图所示，服务器处理 HTTP 请求一般会单独开辟一个协程，假设该处理协程调用了函数 A，函数 A 中也可能创建一个新的协程。

假设新的协程调用了函数 G，函数 G 中又有可能通过 RPC 远程调用了其他服务的 API，并最终调用了函数 F。

假设这个时候上游将连接断开，或者服务处理时间超时，我们希望能够立即退出函数 A、函数 G 和函数 F 所在的协程。

在实际场景中可能是这样的，上游给服务的处理时间是 500ms，超过这一时间这一请求就无效了。

A 服务当前已经花费了 200ms 的时间，G 又用了 100ms 调用 RPC，那么留给 F 的处理时间就只有 200ms 了。

如果远程服务 F 在 200ms 后没有返回，所有协程都需要感知到并快速关闭。

而使用 Context 标准库就是当前处理这种协程级联退出的标准做法。

Context 的使用方法。

Context 标准库中重要的结构 context.Context 其实是一个接口，它提供了 Deadline、Done、Err、Value 这 4 种方法：

type Context interface {
  Deadline() (deadline time.Time, ok bool)
  Done() <-chan struct{}
  Err() error
  Value(key interface{}) interface{}
}

Deadline 方法用于返回 Context 的过期时间。Deadline 第一个返回值表示 Context 的过期时间，第二个返回值表示是否设置了过期时间，如果多次调用 Deadline 方法会返回相同的值。
Done 是使用最频繁的方法，它会返回一个通道。一般的做法是调用者在 select 中监听该通道的信号，如果该通道关闭则表示服务超时或异常，需要执行后续退出逻辑。多次调用 Done 方法会返回相同的通道。
通道关闭后，Err 方法会返回退出的原因。
Value 方法返回指定 key 对应的 value，这是 Context 携带的值。key 必须是可比较的，一般的用法 key 是一个全局变量，通过context.WithValue 将 key 存储到 Context 中，并通过Context.Value 方法取出。

Context 接口中的这四个方法可以被多次调用，其返回的结果相同。同时，Context 的接口是并发安全的，可以被多个协程同时使用。

context.Value

一般在远程过程调用中使用
例如存储分布式链路跟踪的 traceId 或者鉴权相关的信息，并且该值的作用域在请求结束时终结。
同时 key 必须是访问安全的，因为可能有多个协程同时访问它。

如下所示，withAuth 函数是一个中间件，它可以让我们在完成实际的 HTTP 请求处理前进行 hook。
在这个例子中，我们获取了 HTTP 请求 Header 头中的鉴权字段 Authorization，并将其存入了请求的上下文 Context 中。
而实际的处理函数 Handle 会从 Context 中获取并验证用户的授权信息，以此判断用户是否已经登录。

const TokenContextKey = "MyAppToken"

// 中间件
func WithAuth(a Authorizer, next http.Handler) http.Handler {
  return http.HandleFunc(func(w http.ResponseWriter, r *http.Request) {
    auth := r.Header.Get("Authorization")
    if auth == "" {
      next.ServeHTTP(w, r) // 没有授权
      return
    }
    token, err := a.Authorize(auth)
    if err != nil {
      http.Error(w, err.Error(), http.StatusUnauthorized)
      return
    }
    ctx := context.WithValue(r.Context(), TokenContextKey, token)
    next.ServeHTTP(w, r.WithContext(ctx))
  })
}

// HTTP请求实际处理函数
func Handle(w http.ResponseWriter, r *http.Request) {
  // 获取授权
  if token := r.Context().Value(TokenContextKey); token != nil {
    // 用户登录
  } else {
    // 用户未登录
  }
}

Context 是一个接口，这意味着需要有对应的具体实现。用户可以自己实现 Context 接口，并严格遵守 Context 接口规定的语义。当然，我们使用得最多的还是 Go 标准库中的实现。

context

当我们调用 context.Background 函数或 context.TODO 函数时，会返回最简单的 Context 实现。
context.Background 返回的 Context 一般是作为根对象存在，不具有任何功能，不可以退出，也不能携带值。

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)
func WithValue(parent Context, key, val interface{}) Context

WithCancel 函数会返回一个子 Context 和 cancel 方法。子 Context 会在两种情况下触发退出：一种情况是调用者主动调用了返回的 cancel 方法；另一种情况是当参数中的父 Context 退出时，子 Context 将级联退出。
WithTimeout 函数指定超时时间。当超时发生后，子 Context 将退出。因此，子 Context 的退出有三种时机，一种是父 Context 退出；一种是超时退出；最后一种是主动调用 cancel 函数退出。
WithDeadline 和 WithTimeout 函数的处理方法相似，不过它们的参数指定的是最后到期的时间。
WithValue 函数会返回带 key-value 的子 Context。

Context 最佳实践

在网络连接到请求处理的多个阶段，都可能有相对应的超时时间。

以 HTTP 请求为例，http.Client 有一个参数 Timeout 用于指定当前请求的总超时时间，它包括从连接、发送请求、到处理服务器响应的时间的总和。

c := &http.Client{
    Timeout: 15 * time.Second,
}
resp, err := c.Get("<https://baidu.com/>")

标准库 client.Do 方法内部会将超时时间换算为截止时间并传递到下一层。setRequestCancel 函数内部则会调用 context.WithDeadline ，派生出一个子 Context 并赋值给 req 中的 Context。

func (c *Client) do(req *Request) (retres *Response, reterr error) {
  ...
  deadline      = c.deadline()
  c.send(req, deadline);
}

func setRequestCancel(req *Request, rt RoundTripper, deadline time.Time) {
    req.ctx, cancelCtx = context.WithDeadline(oldCtx, deadline)
    ...
}

在获取连接时，如果从闲置连接中找不到连接，则需要陷入 select 中去等待。如果连接时间超时，req.Context().Done() 通道会收到信号立即退出。在实际发送数据的 transport.roundTrip 函数中.

func (t *Transport) getConn(treq *transportRequest, cm connectMethod) (pc *persistConn, err error){
...
select {
  case <-w.ready:
    return w.pc, w.err
  case <-req.Cancel:
    return nil, errRequestCanceledConn
  case <-req.Context().Done():
    return nil, req.Context().Err()
    return nil, err
  }
}

获取 TCP 连接需要调用 sysDialer.dialSerial 方法，dialSerial 的功能是从 addrList 地址列表中取出一个地址进行连接，如果与任一地址连接成功则立即返回。代码如下所示，不出所料，该方法的第一个参数为上游传递的 Context。

// net/dial.go
func (sd *sysDialer) dialSerial(ctx context.Context, ras addrList) (Conn, error) {
  for i, ra := range ras {
    // 协程是否需要退出
    select {
    case <-ctx.Done():
      return nil, &OpError{Op: "dial", Net: sd.network, Source: sd.LocalAddr, Addr: ra, Err: mapErr(ctx.Err())}
    default:
    }

    dialCtx := ctx

     // 是否设置了超时时间
    if deadline, hasDeadline := ctx.Deadline(); hasDeadline {
      // 计算连接的超时时间
      partialDeadline, err := partialDeadline(time.Now(), deadline, len(ras)-i)
      if err != nil {
        // 已经超时了.
        if firstErr == nil {
          firstErr = &OpError{Op: "dial", Net: sd.network, Source: sd.LocalAddr, Addr: ra, Err: err}
        }
        break
      }
      // 派生出新的context，传递给下游
      if partialDeadline.Before(deadline) {
        var cancel context.CancelFunc
        dialCtx, cancel = context.WithDeadline(ctx, partialDeadline)
        defer cancel()
      }
    }

    c, err := sd.dialSingle(dialCtx, ra)
    ...
}

我们来看看 dialSerial 函数几个比较有代表性的 Context 用法。

首先，第 3 行代码遍历地址列表时，判断 Context 通道是否已经退出，如果没有退出，会进入到 select 的 default 分支。如果通道已经退出了，则直接返回，因为继续执行已经没有必要了。
接下来，第 14 行代码通过 ctx.Deadline() 判断是否传递进来的 Context 有超时时间。
如果有超时时间，我们需要协调好后面每一个连接的超时时间。
例如，我们总的超时时间是 600ms，一共有 3 个连接，那么每个连接分到的超时时间就是 200ms，这是为了防止前面的连接过度占用了时间。partialDeadline 会帮助我们计算好每一个连接的新的到期时间，如果该到期时间小于总到期时间，我们会派生出一个子 Context 传递给 dialSingle 函数，用于控制该连接的超时。
dialSingle 函数中调用了 ctx.Value，用来获取一个特殊的接口 nettrace.Trace。nettrace.Trace 用于对网络包中一些特殊的地方进行 hook。dialSingle 函数作为网络连接的起点，如果上下文中注入了 trace.ConnectStart 函数，则会在 dialSingle 函数之前调用 trace.ConnectStart 函数，如果上下文中注入了 trace.ConnectDone 函数，则会在执行 dialSingle 函数之后调用 trace.ConnectDone 函数。

func (sd *sysDialer) dialSingle(ctx context.Context, ra Addr) (c Conn, err error) {
  trace, _ := ctx.Value(nettrace.TraceKey{}).(*nettrace.Trace)
  if trace != nil {
    raStr := ra.String()
    if trace.ConnectStart != nil {
      trace.ConnectStart(sd.network, raStr)
    }
    if trace.ConnectDone != nil {
      defer func() { trace.ConnectDone(sd.network, raStr, err) }()
    }
  }
  la := sd.LocalAddr
  switch ra := ra.(type) {
  case *TCPAddr:
    la, _ := la.(*TCPAddr)
    // tcp连接
    c, err = sd.dialTCP(ctx, la, ra)
    ...  
}

由于标准库为我们提供了 Timeout 参数，我们在项目中实践超时控制就容易多了。只要在 BrowserFetch 结构体中增加 Timeout 超时参数，然后设置超时参数到 http.Client 中就大功告成了。

Context 底层原理

Context 在很大程度上利用了通道的一个特性：通道在 close 时，会通知所有监听它的协程。

每个派生出的子 Context 都会创建一个新的退出通道，这样，只要组织好 Context 之间的关系，就可以实现继承链上退出信号的传递。如图所示的三个协程中，关闭通道 A 会连带关闭调用链上的通道 B，通道 B 会关闭通道 C。

Context.Background 函数和 Context.TODO 函数会生成一个根 Context。

要使用 context 的退出功能，需要调用 WithCancel 或 WithTimeout，派生出一个新的结构 Context。

WithCancel 底层对应的结构为 cancelCtx，WithTimeout 底层对应的结构为 timerCtx，timerCtx 包装了 cancelCtx，并存储了超时时间。

type cancelCtx struct {
  Context   //保留了父 Context 的信息

  mu       sync.Mutex   
  done     atomic.Value  
  children map[canceler]struct{} //保存了当前 Context 派生的子 Context 的信息
  err      error
}

type timerCtx struct {
  cancelCtx
  timer *time.Timer 

  deadline time.Time
}

而 WithDeadline 函数会先判断父 Context 设置的超时时间是否比当前 Context 的超时时间短。如果是，那么子协程会随着父 Context 的退出而退出，没有必要再设置定时器。

当我们使用了标准库中默认的 Context 实现时，propagateCancel 函数会将子 Context 加入父协程的 children 哈希表中，并开启一个定时器。当定时器到期时，会调用 cancel 方法关闭通道，级联关闭当前 Context 派生的子 Context，并取消与父 Context 的绑定关系。这种特性就产生了调用链上连锁的退出反应。

func (c *cancelCtx) cancel(removeFromParent bool, err error) {
  
  ...
   // 关闭当前通道
  close(d)
  // 级联关闭当前context派生的子context
  for child := range c.children {
    child.cancel(false, err)
  }
  c.children = nil
  c.mu.Unlock()
  // 从父context中能够删除当前context关联
  if removeFromParent {
    removeChild(c.Context, c)
  }
}