在图 5 中，您可以看到 doWork 函数的活动图。在此函数中，我们将使用通道与调用者进行通信。我们创建一个 for 循环，并在该循环内放置一条 select 语句。在这个 select 语句中，我们有两种情况：

ctx.Done() 返回的通道已关闭。这意味着我们收到完成工作的命令。

在这种情况下，我们将中断循环，记录一条消息并返回。

默认情况（如果之前的情况没有执行则执行）

在这种默认情况下，我们将增加总和。

如果变量 sum 变得严格大于 1.000，我们将在结果通道 (resChan) 上发送结果。

服务端的处理

// context/server-side/main.go 
//...
func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Println("[Handler] request received")
        // 取出请求中的上下文
        rCtx := r.Context()
        // 创建结果接受通道
        resChan := make(chan int)
        // 加载一个异步程序
        go doWork(rCtx, resChan)
        // Wait for
        // 1. 客户端丢失链接.
        // 2. 函数完成
        select {
        case <-rCtx.Done():
            log.Println("[Handler] context canceled in main handler, client has diconnected")
            return
        case result := <-resChan:
            log.Println("[Handler] Received 1000")
            log.Println("[Handler] Send response")
            fmt.Fprintf(w, "Response %d", result) // send data to client side
            return
        }
    })
    err := http.ListenAndServe("127.0.0.1:8989", nil) // set listen port
    if err != nil {
        panic(err)
    }
}

我们更改了处理程序的代码以使用请求上下文。这里要做的第一件事是检索请求的上下文：

rCtx := r.Context()

然后我们设置一个整数通道 (resChan)，它允许您与 doWork 函数进行通信。我们将在单独的 goroutine 中启动 doWork 函数。

resChan := make(chan int)
// launch the function doWork in a goroutine
go doWork(rCtx, resChan)

然后我们将使用 select 语句来等待两个可能的事件：

客户端关闭连接；因此，取消通道将被关闭。

函数 doWork 已经完成了它的工作。（我们从 resChan 通道收到一个整数）

在选项 1 中，我们记录一条消息，然后返回。当选项 2 发生时，我们使用 resChan 通道的结果，并将其写入响应写入器。我们的客户端将收到 doWork 函数计算的结果。 让我们运行我们的服务器和客户端。在图6中您可以看到客户端和服务器程序的执行日志。 可以看到处理程序收到请求，然后启动 doWork 函数。然后处理程序接收取消信号。然后该信号被传播到 doWork 函数。

WithDeadline

WithDeadline 和 WithTimeout 非常相似。如果我们查看 context 包的源代码，我们可以看到函数 WithTimeout 只是 WithDeadline 的包装：

// source : context.go (in the standard library)
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
    return WithDeadline(parent, time.Now().Add(timeout))
}

如果您查看前面的代码片段，您可以看到超时持续时间已添加到当前时间。让我们看看 WithDeadline 函数的签名：

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

该函数有两个参数：

父上下文

特定时间。

用法

正如我们在上一节中所说，截止日期和超时是类似的概念。超时表示为持续时间，而截止日期表示为特定时间点

WithDeadline 可以在使用 WithTimeout 的地方使用。这是标准库的示例：

// golang standard library
// src/net/dnsclient_unix.go
// line 133
// exchange sends a query on the connection and hopes for a response.
func (r *Resolver) exchange(ctx context.Context, server string, q dnsmessage.Question, timeout time.Duration) (dnsmessage.Parser, dnsmessage.Header, error) {
    //....
    for _, network := range []string{"udp", "tcp"} {
        ctx, cancel := context.WithDeadline(ctx, time.Now().Add(timeout))
        defer cancel()
        c, err := r.dial(ctx, network, server)
        if err != nil {
            return dnsmessage.Parser{}, dnsmessage.Header{}, err
        }
        //...
    }
    return dnsmessage.Parser{}, dnsmessage.Header{}, errNoAnswerFromDNSServer
}

这里的exchange函数将上下文作为第一个参数。

对于每个网络（UDP 或 TCP），它派生作为参数传递的上下文。

输入上下文是通过调用 context.WithDeadline 派生的。截止时间是通过将超时持续时间添加到当前时间来创建的：time.Now().Add(timeout)

请注意，创建派生上下文后，立即会延迟调用 context.WithDeadline 返回的取消函数。这意味着当exchange函数返回时，取消函数将被调用。

例如，如果 dial 函数由于某种原因返回错误，则exchange函数将返回，取消函数将被调用，并且取消信号将传播到子上下文。

取消传播

本节将深入探讨取消传播的机制。让我们举个例子：

func main(){
    ctx1 := context.Background()
    ctx2, c := context.WithCancel(ctx1)
    defer c()
}

在这个小程序中，我们首先定义一个根上下文：ctx1。然后我们通过调用 context.WithCancel 来派生此上下文。Go 将创建一个新的结构。将被调用的函数如下：

// src/context/context.go
// newCancelCtx returns an initialized cancelCtx.
func newCancelCtx(parent Context) cancelCtx {
    return cancelCtx{Context: parent}
}

创建了一个 cancelCtx 结构，并将我们的根上下文嵌入其中。这里是类型 struct cancelCtx ：

// src/context/context.go
type cancelCtx struct {
    Context
    mu       sync.Mutex            // protects the following fields
    done     chan struct{}         // created lazily, closed by the first cancel call
    children map[canceler]struct{} // set to nil by the first cancel call
    err      error                 // set to non-nil by the first cancel call
}

我们有五个字段：

上下文（父级）是一个嵌入字段（它没有明确的字段名称）

互斥锁（名为 mu）

名为done的通道

名为children 的字段是一个map。键的类型为 canceller，值的类型为 struct{}

还有一个名为 err 的错误

Canceller 是一个接口：

type canceler interface {
    cancel(removeFromParent bool, err error)
    Done() <-chan struct{}
}

实现接口取消器的类型必须实现函数：取消函数和完成函数。

当我们执行取消函数时会发生什么？ctx2 会发生什么？

互斥量 (mu) 将被锁定。因此，没有其他 goroutine 能够修改这个上下文。

通道（完成）将被关闭

ctx2 的所有子级也将被取消（在这种情况下，我们没有子级…）

互斥体将被解锁。

两次传播

func main() {
    ctx1 := context.Background()
    ctx2, c2 := context.WithCancel(ctx1)
    ctx3, c3 := context.WithCancel(ctx2)
    //...
}

这里我们创建了 ctx3，一个类型为 cancelCtx 的新对象。子上下文 ctx3 将添加到父上下文 (ctx2)。父上下文 ctx2 将保留其子上下文的记忆。 目前，它只有一个子 ctx3。现在让我们看看当我们调用取消函数 c2 时发生了什么。

互斥量 (mu) 将被锁定。因此，没有其他 goroutine 能够修改这个上下文。

通道（完成）将被关闭

ctx2 的所有子级也将被取消（在这种情况下，我们没有子级…）ctx3将通过相同的过程被取消

ctx1（ctx2 的父级）是一个空的 Ctx，因此 ctx2 不会从 ctx1 中删除。

互斥体将被解锁。

三次传播

func main() {
    ctx1 := context.Background()
    ctx2, c2 := context.WithCancel(ctx1)
    ctx3, c3 := context.WithCancel(ctx2)
    ctx4, c4 := context.WithCancel(ctx3)
}

正如您在图 中看到的，我们有一个根上下文和三个后代。

最后一个是ctx4当我们调用 c2 时，它将取消 ctx2 及其子项 (ctx3)。

当 ctx3 被取消时，它也将取消其所有子项，并且 ctx4 将被取消。

本节的关键信息是“当您取消上下文时，取消操作将从父级传播到子级”。

一个重要的习惯用法：defer cancel()

下面两行代码很常见：

ctx, cancel = context.WithCancel(ctx)
defer cancel()

您可能会在标准库中遇到这些行，但也在许多库中遇到这些行。一旦我们派生出现有上下文，就会在 defer 语句中调用 cancel 函数。 正如我们之前所看到的，取消指令从父母传播到孩子；为什么我们需要显式调用cancel？在构建库时，您不确定是否有人会在父上下文中有效地执行取消函数。通过在延迟语句中添加对取消的调用，您可以确保调用取消：

当函数返回时（或到达其主体的末尾）

或者当运行该函数的 goroutine 发生恐慌时。

Goroutine泄露

为了理解这个现象，我们举一个例子。 首先，我们定义两个函数：doSth 和 doSth2。这两个函数是虚拟的。他们将上下文作为第一个参数。然后他们无限期地等待 ctx.Done() close 返回的通道：

func doSth2(ctx context.Context) {
    select {
    case <-ctx.Done():
        log.Println("second goroutine return")
        return
    }
}
func doSth(ctx context.Context) {
    select {
    case <-ctx.Done():
        log.Println("first goroutine return")
        return
    }
}

我们现在将在名为 launch 的第三个函数中使用这两个函数：

func launch() {
    ctx := context.Background()
    ctx, _ = context.WithCancel(ctx)
    log.Println("launch first goroutine")
    go doSth(ctx)
    log.Println("launch second goroutine")
    go doSth2(ctx)
}

在此函数中，我们首先创建一个根上下文（由 context.Background 返回）。然后我们导出这个根上下文。我们调用 WithCancel() 方法来获取可以取消的上下文。 然后我们启动两个 goroutine。现在让我们看一下我们的主要功能：

// context/goroutine-leak/main.go 
// ...
func main() {
    log.Println("begin program")
    go launch()
    time.Sleep(time.Millisecond)
    log.Printf("Gouroutine count: %d\n", runtime.NumGoroutine())
    for {
    }
}

我们在 goroutine 中启动函数。然后我们暂停一下（1 毫秒），然后计算 goroutine 的数量。运行时包中定义了一个非常方便的函数：

runtime.NumGoroutine()

这里的goroutine数量应该是3：1个主goroutine + 1个执行doSth的goroutine + 1个执行doSth2的goroutine。如果我们不调用 cancel，最后两个 goroutine 将无限期地运行。请注意，我们在程序中创建了另一个 goroutine：启动 launch 的 goroutine。这个 goroutine 不会被计算在内，因为它几乎会立即返回。当我们取消上下文时，我们的两个 goroutine 将返回。因此，goroutine 的数量将减少到 1 个（主协程）。但在这里，我们根本不调用取消函数。

2019/05/04 19:01:16 begin program
2019/05/04 19:01:16 launch first goroutine
2019/05/04 19:01:16 launch second goroutine
2019/05/04 19:01:16 Gouroutine count: 3

在主函数中，我们无法取消上下文（因为它是在启动函数中定义的）。我们有 2 个泄漏的 goroutine！为了解决这个问题，我们只需修改函数 launch 并添加一个延迟语句：

func launch() {
    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()
    log.Println("launch first goroutine")
    go doSth(ctx)
    log.Println("launch second goroutine")
    go doSth2(ctx)
}
2019/05/04 19:15:09 begin program
2019/05/04 19:15:09 launch first goroutine
2019/05/04 19:15:09 launch second goroutine
2019/05/04 19:15:09 first goroutine return
2019/05/04 19:15:09 second goroutine return
2019/05/04 19:15:09 Gouroutine count: 1

WithValue

上下文可以携带数据。此功能旨在与请求范围的数据一起使用，例如：

凭证（例如 JSON Web 令牌）

请求id（用于在系统中跟踪请求）

请求的IP

一些标头（例如：用户代理）

举例

/

/ context/with-value/main.go 
package main
import (
    "context"
    "fmt"
    "log"
    "net/http"
    uuid "github.com/satori/go.uuid"
)
func main() {
    http.HandleFunc("/status", status)
    err := http.ListenAndServe(":8091", nil)
    if err != nil {
        log.Fatal(err)
    }
}
type key int
const (
    requestID key = iota
    jwt
)
func status(w http.ResponseWriter, req *http.Request) {
    // 将请求ID添加到ctx中
    ctx := context.WithValue(req.Context(), requestID, uuid.NewV4().String())
    // 将认证凭证添加到ctx中
    ctx = context.WithValue(ctx, jwt, req.Header.Get("Authorization"))
    upDB, err := isDatabaseUp(ctx)
    if err != nil {
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        return
    }
    upAuth, err := isMonitoringUp(ctx)
    if err != nil {
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        return
    }
    fmt.Fprintf(w, "DB up: %t | Monitoring up: %t\n", upDB, upAuth)
}
func isDatabaseUp(ctx context.Context) (bool, error) {
    // 取出requestId
    reqID, ok := ctx.Value(requestID).(string)
    if !ok {
        return false, fmt.Errorf("requestID in context does not have the expected type")
    }
    log.Printf("req %s - checking db status", reqID)
    return true, nil
}
func isMonitoringUp(ctx context.Context) (bool, error) {
    // 取出requestId
    reqID, ok := ctx.Value(requestID).(string)
    if !ok {
        return false, fmt.Errorf("requestID in context does not have the expected type")
    }
    log.Printf("req %s - checking monitoring status", reqID)
    return true, nil
}

我们创建了一个正在监听 localhost:8091 的服务器

该服务器只有一个路由：“/status”

我们使用 ctx := context.WithValue(req.Context(), requestID, uuid.NewV4().String()) 派生请求上下文 (req.Context())

我们向上下文添加一个键值对：requestID

然后我们更新操作。我们添加一个新的密钥对来保存请求凭据： ctx = context.WithValue(ctx, jwt, req.Header.Get(“Authorization”))

然后可以通过 isDatabaseUp 和 isMonitoringUp 访问上下文值：

reqID, ok := ctx.Value(requestID).(string)
if !ok {
    return false, fmt.Errorf("requestID in context does not have the expected type")
}

★ 注： 在链路跟踪过程中，比较好的日志打印方式就是将traceID 作为日志的常驻字段后，将日志的子对象存入到ctx中，后面需要使用日志打印时，从ctx中取出log实例进行日志打印。

”

Key type

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

参数 key 和 val 的类型为 interface{}。换句话说，它们可以具有任何类型。仅应遵守一项限制，即key类型应具有可比性。我

们可以在多个包之间共享上下文。

您可能希望限制对添加值的包外部的上下文值的访问。

为此，您可以创建一个未导出的类型

所有的key都是这种类型的。

我们将在包内全局定义键：

type key int
const (
    requestID key = iota
    jwt
)

在前面的示例中，我们创建了一个具有基础类型 int （可比较）的类型键。然后我们定义了两个未导出的全局常量。然后使用这些常量添加值并从上下文中检索值：

/

/ add a value
ctx := context.WithValue(req.Context(), requestID, uuid.NewV4().String())
// get a value
reqID, ok := ctx.Value(requestID).(string)

预期缺失值和类型与实际类型不同

当在上下文中找不到键值对时，ctx.Value 将返回 nil。

这就是我们进行类型断言的原因：保护我们免受缺失值或不具有所需类型的值的影响。