context.WithCancel

func doSomething(ctx context.Context) {
	ctx, cancelctx := context.WithCancel(ctx)
	printCh := make(chan int)
	go doAnother(ctx, printCh)


	for i := 0; i < 3; i++ {
		printCh <- i
	}
	cancelctx()

	fmt.Println("do something finished")

}

func doAnother(ctx context.Context, printCh chan int) {
	for {
		select {
		case <-ctx.Done():
			if err := ctx.Err(); err != nil {
				fmt.Printf("do Another with error, %s \n", err)
			}
			fmt.Println("do Another finished")
			return
		case data := <-printCh:
			fmt.Printf("receive %d \n", data)
		}

	}

}

我们在doSomething方法中加了一个可以取消的Context， 然后定义了一个channel, 往channel里面放入3个数，另外启动一个goroutine doAnother 来接收它, 在完成放入数据后我们调用了取消方法， 通知doAnother 结束掉。 这样程序就达到一个goroutine通知另外一个goroutine的效果， 程序运行结果如下

receive 0 
receive 1 
receive 2
do Another with error, context canceled
do Another finished
do something finished

通过打印的输出我们可以看到doAnother是通过canneled来结束的。
如果我们再加一个goroutine，也能够通过context来取消。 这里比较简单不贴代码了。

context.WithTimeout

如果只是单纯的通知另外一个goroutine，直接通过close channel也可以做到了， Context还可以通过WithTimeout设定超时时间来限定程序运行多久，我们简单改造一下上面的代码

func doSomething(ctx context.Context) {
	ctx, cancelctx := context.WithTimeout(ctx, 1500*time.Millisecond)
	defer cancelctx()

	printCh := make(chan int)
	go doAnother(ctx, printCh)

outer:
	for i := 0; i < 3; i++ {
		select {
		case printCh <- i:
			time.Sleep(1 * time.Second)
		case <-ctx.Done():
			break outer
		}
	}
	cancelctx()

	fmt.Println("do something finished")

我们把doSomething改造了一下， 通过context.WithTimeout(ctx, 1500*time.Millisecond)将context 改成运行1.5秒就退出, doAnother 保持不变， 然后发送的时候，发送一个就sleep 1秒。 运行效果如下

receive 0 
receive 1 
do Another with error, context deadline exceeded 
do Another finished
do something finished

我们可以看到只发送了两个数，就退出了，退出的原因是exceeded. 这样就达到了控制goroutine运行时间的效果。
通过context.WithDeadline 也可以达到和WithTimeout一样的效果，只是一个是按时间点来停，一个是按时间段来停， 示例代码如下

deadLineTime := time.Now().Add(1500 * time.Millisecond)
ctx, cancelctx := context.WithDeadline(ctx, deadLineTime)

context.WithValue

context还有个用途是用来记录和传递value, 比如我们可以向别的goroutine传递UserID，RequestID等要跟踪的变量信息。 还是通过示例代码来说明

func main() {
	var ctx = context.Background()
	key := 1
	ctx = context.WithValue(ctx, key, "someValue")
	doSomething(ctx)
}

func doSomething(ctx context.Context) {
	fmt.Printf("Doing something! %s \n", ctx.Value(1))

}

输出结果很简单就是"Doing something! someValue" 这个someValue就是通过Context传递给doSomething方法里面的。 如果ctx.Value的key不存在，也不会报错，会返回nil.
上面key的写法，Visual Studio Code会提示”should not use built-in type int as key for value; define your own type to avoid collisions“
就是说这个key可能冲突，比如你的程序用String "userID", 别人也用String ”userID“, 你取的时候取到别人用的了，那样就给程序带来隐患， 我们需要自定义key, 如下代码示例

type ctxKey int

const (
	ctxUserKey ctxKey = iota
	ctxAuthToken
)

func main() {
	var ctx = context.Background()
	ctx = context.WithValue(ctx, ctxUserKey, "someValue")
	doSomething(ctx)
}

func doSomething(ctx context.Context) {
	fmt.Printf("Doing something! %s \n", ctx.Value(ctxUserKey))

}

我们定义了常量ctxUserKey， 它是ctxKey类型，ctxUserKey它的实际值是0， 在取值和赋值的时候我们同意用ctxUserKey， 这样就能很清楚明白的拿到它的value. 如果我们用ctx.Value(0)是拿不到值的。

最后

作者在书中说context包的包一直存在争议，为什么呢？ 因为它可以放入任意类型，这样就让有些偷懒的程序员把它当垃圾桶， 程序运行需要的参数也用它来传递，这样它就被赋予了太多它不应该的功能。 那么我们需要遵守一定的规则来使用它，作者给出了建议
1, 数据应该通过进程或API边界， 这句话感觉是翻译问题，不是特别清楚，我感觉作者的意思是通过明确的参数来传递数据，而不是context
2，数据应该是不可变的。 意思就是只WithValue一次，不要去修改它
3，数据应该趋向简单类型， 保持简单很重要
4，数据应该是数据，而不是类型与方法， 也是保持简单
5，数据应该用于装饰操作，而不是驱动操作。意思就是你不要通过context里面的内容来决定你的代码逻辑。

作者最后说context提供的取消功能非常有用， 就是WithValue不要滥用。这一章感觉翻译的不好，读起来很晦涩，我还是看了另外一篇文章搞明白的。 贴出链接在此https://www.digitalocean.com/community/tutorials/how-to-use-contexts-in-go