https://golang.org/pkg/context/#pkg-overview
https://blog.csdn.net/yzf279533105/article/details/107290645
https://blog.csdn.net/u013210620/article/details/78596861
https://studygolang.com/articles/18931?fr=sidebar

网络请求超时控制

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

Deadline()返回一个time.Time，是当前 Context 的应该结束的时间，ok 表示是否有 deadline
Done()返回一个struct{}类型的只读 channel
Err()返回 Context 被取消时的错误。如果Done没有关闭，Err()返回nil。若不为nil，返回的理由可能为：1. context被终止了 2.context的deadline到了
Value(key interface{}) 是 Context 自带的 K-V 存储功能

WithCancel

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

WithCancel返回一个新的parent拷贝Done channel。当调用返回的cancel函数或parent的上下文的Done channel被关闭时（以先发生的为准），将关闭返回的上下文的Done channel。
取消此上下文将释放与其关联的资源，因此在此上下文中运行的操作完成后，代码应立即调用cancel。

示例
此示例演示了使用可取消的context来防止goroutine泄漏。 在示例函数结束时，由gen方法启动的goroutine将返回而不会泄漏。

package main
import (
	"context"
	"fmt"
)
func main() {
	// gen generates integers in a separate goroutine and
	// sends them to the returned channel.
	// The callers of gen need to cancel the context once
	// they are done consuming generated integers not to leak
	// the internal goroutine started by gen.
	gen := func(ctx context.Context) <-chan int {
		dst := make(chan int)
		n := 1
		go func() {
			for {
				select {
				case <-ctx.Done():
					return // returning not to leak the goroutine
				case dst <- n:
					n++
				}
			}
		}()
		return dst
	}

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel() // cancel when we are finished consuming integers

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

WithTimeout

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
WithTimeout内部调用了WithDeadline，返回结果为WithDeadline(parent, time.Now().Add(timeout)).
取消此上下文将释放与之关联的资源，因此在此上下文中运行的操作完成后，代码应立即调用cancel：
示例
此示例传递了带有超时的上下文，以告知阻塞函数在超时结束后应放弃任务。

package main

import (
	"context"
	"fmt"
	"time"
)

const shortDuration = 1 * time.Millisecond

func main() {
	// Pass a context with a timeout to tell a blocking function that it
	// should abandon its work after the timeout elapses.
	ctx, cancel := context.WithTimeout(context.Background(), shortDuration)
	defer cancel()

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

}
// 执行后1ms立刻输出 "context deadline exceeded"

示例2

package main

import (
  "context"
  "fmt"
  "time"
)

const shortDuration = 500 * time.Millisecond

func work(ctx context.Context, doneChan chan struct{}) {
  defer func() {
    fmt.Println("work end")
  }() 
  fmt.Println("work start")
  time.Sleep(2 * time.Second)
  fmt.Println("work finished")
  doneChan <- struct{}{}
}
func main() {
  doneChan := make(chan struct{}, 1)
  dlCtx, cancel := context.WithTimeout(context.Background(), shortDuration)
  fmt.Println("main start")

  go work(dlCtx, doneChan)
  select{
  case <- dlCtx.Done(): // 取出值,说明已经结束
    fmt.Println("timeout")
    cancel()
  case <- doneChan:
    fmt.Println("finish")
  }

  fmt.Println("go work end")                                                                                                                                                                                                          
  time.Sleep(3 * time.Second)
  fmt.Println("main end")
}

输出：

main start
work start
timeout
go work end
work finished
work end
main end

WithDeadline

WithDeadline返回parent上下文的副本，并将截止时间调整为不迟于d。 如果parent的deadline早于d，则WithDeadline（parent，d）在语义上等效于parent。 当deadline到期、调用返回的cancel函数、关闭parent上下文的Done channel（以先到者为准）时，将关闭返回的上下文的Done channel。

示例：

package main

import (
	"context"
	"fmt"
	"time"
)

const shortDuration = 1 * time.Millisecond

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

	// Even though ctx will be expired, it is good practice to call its
	// cancellation function in any case. Failure to do so may keep the
	// context and its parent alive longer than necessary.
	defer cancel()

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

}

WithValue

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

WithValue返回parent的副本，其中与键关联的值为val。

仅将上下文值用于传递流程和API的请求范围的数据，而不用于将可选参数传递给函数。

提供的key必须具有可比性，并且不能为字符串类型或任何其他内置类型，以避免使用上下文在程序包之间发生冲突。 WithValue的用户应定义自己的key类型。 为了避免在分配给interface{}时进行分配，context key常具有具体的类型struct {}。 或者，导出的context key变量的静态类型应为指针或接口。

package main

import (
	"context"
	"fmt"
)

func main() {
	type favContextKey string

	f := func(ctx context.Context, k favContextKey) {
		if v := ctx.Value(k); v != nil {
			fmt.Println("found value:", v)
			return
		}
		fmt.Println("key not found:", k)
	}

	k := favContextKey("language")
	ctx := context.WithValue(context.Background(), k, "Go")

	f(ctx, k)
	f(ctx, favContextKey("color"))

}