Go上下文标准库Context

Generalzy

已于 2024-01-28 23:46:10 修改

阅读量484

点赞数 1

分类专栏： GO 文章标签： go

于 2022-04-10 19:13:59 首次发布

本文链接：https://blog.csdn.net/General_zy/article/details/124082738

版权

GO 专栏收录该内容

51 篇文章 5 订阅

订阅专栏

当一个请求被取消或超时时，所有用来处理该请求的 goroutine 都应该迅速退出，然后系统才能释放这些 goroutine 占用的资源。

全局变量退出协程

package main
import (
	"fmt"
	"sync"
	"time"
)
var wg sync.WaitGroup
var exit bool
// 全局变量方式存在的问题：
// 1. 使用全局变量在跨包调用时不容易统一
// 2. 如果worker中再启动goroutine，就不太好控制了。
func worker() {
	for {
		fmt.Println("worker")
		time.Sleep(time.Second)
		if exit {
			break
		}
	}
	wg.Done()
}
func main() {
	wg.Add(1)
	go worker()
	time.Sleep(time.Second * 3) // sleep3秒以免程序过快退出
	exit = true                 // 修改全局变量实现子goroutine的退出
	wg.Wait()
	fmt.Println("over")
}

channel退出协程

package main
import (
	"fmt"
	"sync"
	"time"
)
var wg sync.WaitGroup
// 管道方式存在的问题：
// 1. 使用全局变量在跨包调用时不容易实现规范和统一，需要维护一个共用的channel
func worker(exitChan chan struct{}) {
LOOP:
	for {
		fmt.Println("worker")
		time.Sleep(time.Second)
		select {
		case <-exitChan: // 等待接收上级通知
			break LOOP
		default:
		}
	}
	wg.Done()
}
func main() {
	var exitChan = make(chan struct{})
	wg.Add(1)
	go worker(exitChan)
	time.Sleep(time.Second * 3) // sleep3秒以免程序过快退出
	exitChan <- struct{}{}      // 给子goroutine发送退出信号
	close(exitChan)
	wg.Wait()
	fmt.Println("over")
}

context退出协程

package main
import (
	"context"
	"fmt"
	"sync"
	"time"
)
var wg sync.WaitGroup
func worker(ctx context.Context) {
LOOP:
	for {
		fmt.Println("worker")
		time.Sleep(time.Second)
		select {
		case <-ctx.Done(): // 等待上级通知
			break LOOP
		default:
		}
	}
	wg.Done()
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	wg.Add(1)
	go worker(ctx)
	time.Sleep(time.Second * 3)
	cancel() // 通知子goroutine结束
	wg.Wait()
	fmt.Println("over")
}

Context

Go 1.7 标准库引入 context 包，中文翻译为 “上下文”，准确说它是 goroutine 的上下文，它包含 goroutine 的运行状态、环境、现场等信息。
context 主要用来在 goroutine 之间传递上下文信息，包括：取消信号、超时时间、截止时间、共享数据等。
专门用来简化对于处理单个请求的多个 goroutine 之间与请求域的数据、取消信号、截止时间等相关操作，这些操作可能涉及多个 API 调用。
服务器传入的请求应该创建上下文，而对服务器的传出调用应该接受上下文。它们之间的函数调用链必须传递上下文，或者可以使用WithCancel、WithDeadline、WithTimeout或WithValue创建的派生上下文。
当一个上下文被取消时，它派生的所有上下文也被取消。

Background()和TODO()

Go内置两个函数：Background()和TODO()，这两个函数分别返回一个实现了Context接口的background和todo。代码中最开始都是以这两个内置的上下文对象作为最顶层的partent context，衍生出更多的子上下文对象。
Background()主要用于main函数、初始化以及测试代码中，作为Context这个树结构的最顶层的Context，也就是根Context，它没有任何功能，不能被取消，没有值，也没有超时时间。
TODO()，它目前还不知道具体的使用场景，如果我们不知道该使用什么Context的时候，可以使用这个。
background和todo本质上都是emptyCtx结构体类型，是一个不可取消，没有设置截止时间，没有携带任何值的Context。

Context接口

context.Context是一个接口，该接口定义了四个需要实现的方法。

type Context interface {
	// Deadline方法需要返回当前Context被取消的时间，也就是完成工作的截止时间（deadline）；
    Deadline() (deadline time.Time, ok bool)
    // Done方法需要返回一个Channel，这个Channel会在当前工作完成或者上下文被取消之后关闭，多次调用Done方法会返回同一个Channel；
    Done() <-chan struct{}
    // Err方法会返回当前Context结束的原因，它只会在Done返回的Channel被关闭时才会返回非空的值；
    Err() error
    // Value方法会从Context中返回键对应的值，对于同一个上下文来说，多次调用Value 并传入相同的Key会返回相同的结果，该方法仅用于传递跨API和进程间跟请求域的数据；
    Value(key interface{}) interface{}
}

在 Go 语言程序中，关闭协程可以通过 channel+select 方式实现，而不是直接杀死协程。
但是在某些场景下，例如某个请求衍生了很多协程，这些协程之间是相互关联，共享一些全局变量、有共同的生命周期，而且需要同时关闭，再用 channel+select 就会比较繁琐，而且有可能出现协程泄露问题。
类似的场景，就可以通过 context 来实现。
其实 context 源码中也是通过 channel+select 来实现的，而且内部还构造了一棵派生关系树，便于生命周期、广播通知等管理，所以我们无需再造轮子。

有了根节点 Context，可以使用它作为参数，使用 context 包提供的四个函数创建子节点 Context：

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

With系列函数

WithCancel

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

WithCancel 函数的参数是父Context。
WithCancel 的返回值是父Context的副本 ctx 和一个取消函数 CancelFunc。
当返回的取消函数被调用时，或者父Context的 Done 通道被关闭时，返回的Context的 Done 通道将被关闭，顺序以最先发生的为准。
取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel。

func gen(ctx context.Context) <-chan int {
		dst := make(chan int)
		n := 1
		go func() {
			for {
				select {
				case <-ctx.Done():
					return // return结束该goroutine，防止泄露
				case dst <- n:
					n++
				}
			}
		}()
		return dst
	}
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	// 当我们取完需要的整数后调用cancel
	defer cancel()

	for n := range gen(ctx) {
		fmt.Println(n)
		if n == 5 {
			break
		}
	}
}

WithDeadline

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

WithDeadline 函数的参数是父Context 和截止时间 deadline。
WithDeadline 的返回值是父Context的副本 ctx 和一个取消函数 CancelFunc。
当协程运行到截止时间、返回的取消函数被调用，或者父Context的 Done 通道被关闭时，返回的Context的 Done 通道将被关闭。
返回父上下文的副本，并将deadline调整为不迟于d。如果父上下文的deadline已经早于d，则WithDeadline(parent, d)在语义上等同于父上下文。当截止日过期时，当调用返回的cancel函数时，或者当父上下文的Done通道关闭时，返回上下文的Done通道将被关闭，以最先发生的情况为准。

package main

import (
    "context"
    "time"
)

func contextTest(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            // 被取消或者超时就结束协程
            println("goroutin finished")
            return
        default:
        }
        // 每隔 1 秒钟，打印 running
        time.Sleep(time.Second)
        println("running")
    }
}

func main() {
    // 3 秒后自动取消运行中的协程
    ctx, _ := context.WithDeadline(context.Background(),time.Now().Add(3 * time.Second))
    go contextTest(ctx)

    // 等待 5 秒钟，让 contextTest 协程优雅结束。
    time.Sleep(5*time.Second)
}

func main() {
	d := time.Now().Add(50 * time.Millisecond)
	ctx, cancel := context.WithDeadline(context.Background(), d)

	// 尽管ctx会过期，但在任何情况下调用它的cancel函数都是很好的实践。
	// 如果不这样做，可能会使上下文及其父类存活的时间超过必要的时间。
	defer cancel()

	select {
	case <-time.After(1 * time.Second):
		fmt.Println("overslept")
	case <-ctx.Done():
		fmt.Println(ctx.Err())
	}
}

上面的代码中，定义了一个50毫秒之后过期的deadline，然后我们调用context.WithDeadline(context.Background(), d)得到一个上下文（ctx）和一个取消函数（cancel），然后使用一个select让主程序陷入等待：等待1秒后打印overslept退出或者等待ctx过期后退出。

在上面的示例代码中，因为ctx 50毫秒后就会过期，所以ctx.Done()会先接收到context到期通知，并且会打印ctx.Err()的内容。

WithTimeout

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

WithTimeout 函数的参数是父Context 和超时时间 timeout。
WithTimeout 的返回值是父Context的副本 ctx 和一个取消函数 CancelFunc。
当协程运行时间超过 timeout、返回的取消函数被调用，或者父Context的 Done 通道被关闭时，返回的Context的 Done 通道将被关闭。
取消此上下文将释放与其相关的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel，通常用于数据库或者网络连接的超时控制。

ar wg sync.WaitGroup

func worker(ctx context.Context) {
LOOP:
	for {
		fmt.Println("db connecting ...")
		time.Sleep(time.Millisecond * 10) // 假设正常连接数据库耗时10毫秒
		select {
		case <-ctx.Done(): // 50毫秒后自动调用
			break LOOP
		default:
		}
	}
	fmt.Println("worker done!")
	wg.Done()
}

func main() {
	// 设置一个50毫秒的超时
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
	wg.Add(1)
	go worker(ctx)
	time.Sleep(time.Second * 5)
	cancel() // 通知子goroutine结束
	wg.Wait()
	fmt.Println("over")
}

WithValue

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

WithValue 函数的参数是父Context 和 key、val。key 和 val是一个键值对。
WithValue 的返回值是父Context的副本 ctx。
WithValue 仅对传递进程和api的请求范围内的数据使用上下文值，而不是将可选参数传递给函数。
提供的键必须是可比较的，不要使用字符串类型或任何其他内置类型，以避免使用上下文的包之间的冲突，使用者应该定义他们自己的键类型，通常为具体 struct{} 类型。或者，导出的上下文键变量的静态类型应该是一个指针或接口。

type TraceCode string

var wg sync.WaitGroup

func worker(ctx context.Context) {
	key := TraceCode("TRACE_CODE")
	traceCode, ok := ctx.Value(key).(string) // 在子goroutine中获取trace code
	if !ok {
		fmt.Println("invalid trace code")
	}
LOOP:
	for {
		fmt.Printf("worker, trace code:%s\n", traceCode)
		time.Sleep(time.Millisecond * 10) // 假设正常连接数据库耗时10毫秒
		select {
		case <-ctx.Done(): // 50毫秒后自动调用
			break LOOP
		default:
		}
	}
	fmt.Println("worker done!")
	wg.Done()
}

func main() {
	// 设置一个50毫秒的超时
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
	// 在系统的入口中设置trace code传递给后续启动的goroutine实现日志数据聚合
	ctx = context.WithValue(ctx, TraceCode("TRACE_CODE"), "12512312234")
	wg.Add(1)
	go worker(ctx)
	time.Sleep(time.Second * 5)
	cancel() // 通知子goroutine结束
	wg.Wait()
	fmt.Println("over")
}

使用Context的注意事项

不要将 Context 塞到结构体里，而是直接将 Context 类型作为函数的第一参数，而且一般都命名为 ctx。
不要向函数传入一个 nil 的 Context，如果你实在不知道传什么，标准库给你准备好了一个 context.TODO()。
不要把本应该作为函数参数的类型塞到 Context Context 存储的应该是一些共同的数据。例如：登陆的 session、cookie 等。
同一个 Context 可能会被传递到多个 goroutine，别担心，Context 是并发安全的。

函数结束协程结束吗

main函数中的协程，如果main结束了，协程也会结束，其他函数里的协程，函数结束了，只要main没结束，协程就会执行。
Go语言中，若在子go程中创建一个新 go程，子go程释放（销毁），新创建的go程不会随着子go程的销毁而销毁。（go程共享堆，不共享栈，go程由程序员在go的代码里显示调度（释放），子go程的栈被释放（回收），由于栈独立，因此新创建的go程的栈不会被释放。）
Go语言中，若在主go程中创建一个新 go程，主go程释放（销毁），新创建的go程随着主go程的销毁而销毁。（go程共享堆，不共享栈，go程由程序员在go的代码里显示调度（释放）。）

综上：主main退出的话，全部的协程也就退出了。

Context使用场景——收录网友的一些案例

推荐以参数的方式显示传递Context
以Context作为参数的函数方法，应该把Context作为第一个参数。
给一个函数方法传递Context的时候，不要传递nil，如果不知道传递什么，就使用context.TODO()
Context的Value相关方法应该传递请求域的必要数据，不应该用于传递可选参数
Context是线程安全的，可以放心的在多个goroutine中传递

客户端超时取消示例——可以借鉴

package main

import (
	"context"
	"fmt"
	"io/ioutil"
	"net/http"
	"sync"
	"time"
)

// 客户端
type respData struct {
	resp *http.Response
	err  error
}

func doCall(ctx context.Context) {
	transport := http.Transport{
	   // 请求频繁可定义全局的client对象并启用长链接
	   // 请求不频繁使用短链接
	   DisableKeepAlives: true, 	}
	client := http.Client{
		Transport: &transport,
	}

	respChan := make(chan *respData, 1)
	req, err := http.NewRequest("GET", "http://127.0.0.1:8000/", nil)
	if err != nil {
		fmt.Printf("new requestg failed, err:%v\n", err)
		return
	}
	req = req.WithContext(ctx) // 使用带超时的ctx创建一个新的client request
	var wg sync.WaitGroup
	wg.Add(1)
	defer wg.Wait()
	go func() {
		resp, err := client.Do(req)
		fmt.Printf("client.do resp:%v, err:%v\n", resp, err)
		rd := &respData{
			resp: resp,
			err:  err,
		}
		respChan <- rd
		wg.Done()
	}()

	select {
	case <-ctx.Done():
		//transport.CancelRequest(req)
		fmt.Println("call api timeout")
	case result := <-respChan:
		fmt.Println("call server api success")
		if result.err != nil {
			fmt.Printf("call server api failed, err:%v\n", result.err)
			return
		}
		defer result.resp.Body.Close()
		data, _ := ioutil.ReadAll(result.resp.Body)
		fmt.Printf("resp:%v\n", string(data))
	}
}

func main() {
	// 定义一个100毫秒的超时
	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
	defer cancel() // 调用cancel释放子goroutine资源
	doCall(ctx)
}

每秒更新 1 次外卖小哥的位置——可以借鉴

Context 的作用是为了在一组 goroutine 间传递上下文信息，其重便包括取消信号。取消信号可用于通知相关的 goroutine 终止执行，避免无效操作。

先来设想一个场景：打开外卖的订单页，地图上显示外卖小哥的位置，而且是每秒更新 1 次。app 端向后台发起 websocket 连接（现实中可能是轮询）请求后，后台启动一个协程，每隔 1 秒计算 1 次小哥的位置，并发送给端。如果用户退出此页面，则后台需要“取消”此过程，退出 goroutine，系统回收资源。

后端可能的实现如下：

// 功能
func Perform(ctx context.Context) {
        for {
            calculatePos()
            sendResult()
            // 监听哪个通道有响应
            // 没有就阻塞，完成响应就开启下一次循环
            select {
            case <-ctx.Done():
                // 被取消，直接返回
                return
            case <-time.After(time.Second):
                // block 1 秒钟 
            }
        }
    }

主流程可能是这样的：

// main
ctx, cancel := context.WithTimeout(context.Background(), time.Hour)
go Perform(ctx)
// ……
// app 端返回页面，调用cancel 函数
cancel()

注意一个细节：WithTimeOut 函数返回的 context 和 cancelFun 是分开的。context 本身并没有取消函数，这样做的原因是取消函数只能由外层函数调用，防止子节点 context 调用取消函数，从而严格控制信息的流向：由父节点 context 流向子节点 context。

http传递共享的数据threading-local——可以借鉴

对于 Web 服务端开发，往往希望将一个请求处理的整个过程串起来，这就非常依赖于 Thread Local（对于 Go 可理解为单个协程所独有）的变量，而在 Go 语言中并没有这个概念，因此需要在函数调用的时候传递 context。

简单版

package main
import (
    "context"
    "fmt"
)
func main() {
    ctx := context.Background()
    process(ctx)
    ctx = context.WithValue(ctx, "traceId", "codebaoku-2021")
    process(ctx)
}

func process(ctx context.Context) {
    traceId, ok := ctx.Value("traceId").(string)
    if ok {
        fmt.Printf("process over. trace_id=%s\n", traceId)
    } else {
        fmt.Printf("process over. no trace_id\n")
    }
}

process over. no trace_id
process over. trace_id=codebaoku-2021

复杂版

const requestIDKey int = 0

func WithRequestID(next http.Handler) http.Handler {
    return http.HandlerFunc(
        func(rw http.ResponseWriter, req *http.Request) {
            // 从 header 中提取 request-id
            reqID := req.Header.Get("X-Request-ID")
            // 创建 valueCtx。使用自定义的类型，不容易冲突
            ctx := context.WithValue(
                req.Context(), requestIDKey, reqID)
            // 创建新的请求
            req = req.WithContext(ctx)
            // 调用 HTTP 处理函数
            next.ServeHTTP(rw, req)
        }
    )
}
// 获取 request-id
func GetRequestID(ctx context.Context) string {
    ctx.Value(requestIDKey).(string)
}
func Handle(rw http.ResponseWriter, req *http.Request) {
    // 拿到 reqId，后面可以记录日志等等
    reqID := GetRequestID(req.Context())
    ...
}
func main() {
	// 自定义handler
    handler := WithRequestID(http.HandlerFunc(Handle))
    http.ListenAndServe("/", handler)
}

控制10s后，所有协程退出——无用代码

使用context包来实现线程安全退出或超时的控制:控制10s后，所有协程退出

package main

import (
	"context"
	"fmt"
	"strconv"
	"sync"
	"time"
)

func task(ctx context.Context, s string, wg *sync.WaitGroup) {
	defer wg.Done()
	for {
		select {
		case <-ctx.Done():
			fmt.Println(s, "--->我结束了")
			//fmt.Println(ctx.Err())
			return
		default:
			fmt.Println(s)
			time.Sleep(1 * time.Second)
		}
	}
}

func main() {
	var wg sync.WaitGroup
	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
	for i := 0; i < 10; i++ {
		wg.Add(1)
		s := fmt.Sprintf("我是第：%v 个任务", strconv.Itoa(i))
		go task(ctx, s, &wg)
	}
	wg.Wait()
}

~~当并发体超时或main主动停止工作者Goroutine时，每个工作者都可以安全退出。~~

某些网友给出的经典案例：

如果default子句的代码执行了10000000000s，这段时间内，这个协程不会退出，wg也不会done，主协程也无法退出。

一句default让程序等待10000000000s是吧？

default:
	fmt.Println(s)
	time.Sleep(1 * time.Second)

控制某个go协程执行5次就结束——可以借鉴

// 控制goroutine 执行5次结束
func main() {
	// 定义一个运行次数变量
	runCount := 0
	//定义一个waitgroup，等待goroutine执行完成
	var wg sync.WaitGroup
	// 初始化context
	parent := context.Background()
	// 传入初始化的ctx，返回ctx和cancle函数
	ctx, cancle := context.WithCancel(parent)
	wg.Add(1) // 增加一个任务
	go func() {
		for {
			select {
			case <-ctx.Done():
				fmt.Println("任务结束")
				return
			default:
				fmt.Printf("任务执行了%d次\n", runCount)
				runCount++
			}
			// 执行了5次，使用ctx的取消函数将任务取消
			if runCount >= 5 {
				cancle()
				wg.Done() // goroutine执行完成
			}

		}
	}()

	wg.Wait() //等待所有任务完成

}

打印100个素数——可以借鉴

Go语言是带内存自动回收特性的，因此内存一般不会泄漏。当main函数不再使用管道时后台Goroutine有泄漏的风险。我们可以通过context包来避免这个问题，下面是防止内存泄露的素数筛实现：

// 返回生成自然数序列的管道: 2, 3, 4, ...
func GenerateNatural(ctx context.Context) chan int {
    ch := make(chan int)
    go func() {
        for i := 2; ; i++ {
            select {
            //父协程cancel()时安全退出该子协程
            case <- ctx.Done():
                return
            //生成的素数发送到管道
            case ch <- i:
            }
        }
    }()
    return ch
}

// 管道过滤器: 删除能被素数整除的数
func PrimeFilter(ctx context.Context, in <-chan int, prime int) chan int {
    out := make(chan int)
    go func() {
        for {
            if i := <-in; i%prime != 0 {
                select {
                //父协程cancel()时安全退出该子协程
                case <- ctx.Done():
                    return
                case out <- i:
                }
            }
        }
    }()
    return out
}

func main() {
    // 使用一个可由父协程控制子协程安全退出的Context。
    ctx, cancel := context.WithCancel(context.Background())

    ch := GenerateNatural(ctx) // 自然数序列: 2, 3, 4, ...
    
    for i := 0; i < 100; i++ {
        // 新出现的素数打印出来
        prime := <-ch 
        fmt.Printf("%v: %v\n", i+1, prime)
        // 基于新素数构造的过滤器
        ch = PrimeFilter(ctx, ch, prime) 
    }
    
    //输出100以内符合要求的素数后安全退出所有子协程
    cancel()
}

当main函数完成工作前，通过调用cancel()来通知后台Goroutine退出，这样就避免了Goroutine的泄漏。

防止 goroutine 泄漏——可以借鉴

当 n == 5 的时候，直接 break 掉。那么 gen 函数的协程就会执行无限循环，永远不会停下来。

发生了 goroutine 泄漏。

func gen() <-chan int {
    ch := make(chan int)
    go func() {
        var n int
        for {
            ch <- n
            n++
            time.Sleep(time.Second)
        }
    }()
    return ch
}

func main() {
    for n := range gen() {
        fmt.Println(n)
        if n == 5 {
            break
        }
    }
    // ……
}

使用，context优化：

func gen(ctx context.Context) <-chan int {
    ch := make(chan int)
    go func() {
        var n int
        for {
            select {
            case <-ctx.Done():
                return
            case ch<- n:
                n++
                time.Sleep(time.Second)
            }
        }
    }()
    return ch
}
func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 避免其他地方忘记 cancel，且重复调用不影响
    for n := range gen(ctx) {
        fmt.Println(n)
        if n == 5 {
            cancel()
            break
        }
    }
    // ……
}

本案例的gen(ctx)从channel中不断读取数字，当读取到5的时候，立即调用cancel并退出读取channel，主协程可以继续往下走，而

go func() {
    var n int
     for {
         select {
         case <-ctx.Done():
             return
         case ch<- n:
             n++
             time.Sleep(time.Second)
         }
     }
 }()

这部分代码，我们无需关心他什么时候结束，只要知道他会结束，因为我们的确发送了cancel指令。

也许这个当n=5，发送cancel命令时，select已经进入了n++流程，但sleep结束后还是会退出协程，最多channel里多了一个6，但这个6将永远不会出现于主线程中。

整体类图

在这里插入图片描述

context使用吐槽

context是什么就不再赘述，关于context的使用，我有话说，先上案例：

func main() {
    messages := make(chan int, 10)

    // producer
    for i := 0; i < 10; i++ {
        messages <- i
    }

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)

    // consumer
    go func(ctx context.Context) {
        ticker := time.NewTicker(1 * time.Second)
        for _ = range ticker.C {
            select {
            case <-ctx.Done():
                fmt.Println("child process interrupt...")
                return
            default:
                fmt.Printf("send message: %d\n", <-messages)
            }
        }
    }(ctx)

    defer close(messages)
    defer cancel()

    select {
    case <-ctx.Done():
        time.Sleep(1 * time.Second)
        fmt.Println("main process exit!")
    }
}

这是网上某些网友提供的前篇一律的使用案例，context真的被调用了吗？？

如果将

default:
   fmt.Printf("send message: %d\n", <-messages)

改为：

default:
   // 这是个耗时操作
   // 假设他出了一些异常,导致更耗时了
   time.Sleep(time.Second * 10)
   fmt.Printf("send message: %d\n", <-messages)

于是在等待10s后，程序结束了。你传入了5*time.Second的ctx，但你的程序等待了10s，你的ctx有什么用？

我对context取消上下文的用法的理解就是，超时后cancel被调用，然后一分一秒都不需要多等就返回，而不是某些人给出的随便一个真正的耗时操作就可以阻塞主线程到永远。

所以，本文本次更新了一批值得借鉴的context使用方法，也标记了一些傻瓜式的无效使用。

总结下来就是：

Go 1.7 引入 context 包，目的是为了解决一组相关 goroutine 的取消问题，即并发控制。当然还可以用于传递一些共享的数据。这种场景往往在开发后台 server 时会遇到，所以 context 有其适用的场景，而非所有场景。

使用上，先创建一个根结点的 Context，之后根据 context 包提供的四个函数创建相应功能的子结点 context。由于它是并发安全的，所以可以放心地传递。

context 并不完美，有固定的使用场景，切勿滥用。

什么都想引入context只会导致你的程序发生死锁和内存泄露。