1，context作用

1，通过context，我们可以方便地对同一个请求所产生地goroutine进行约束管理，可以设定超时、deadline，甚至是取消这个请求相关的所有goroutine。形象地说，假如一个请求过来，需要A去做事情，而A让B去做一些事情，B让C去做一些事情，A、B、C是三个有关联的goroutine，那么问题来了：假如在A、B、C还在处理事情的时候请求被取消了，那么该如何优雅地同时关闭goroutine A、B、C呢？这个时候就轮到context包上场了。

2，在golang中的创建一个新的线程并不会返回像c语言类似的pid所有我们不能从外部杀死某个线程，所有我就得让它自己结束之前我们用channel＋select的方式，来解决这个问题但是有些场景实现起来比较麻烦，例如由一个请求衍生出多个线程并且之间需要满足一定的约束关系，以实现一些诸如：

有效期，中止线程树，传递请求全局变量之类的功能。

于是google 就为我们提供一个解决方案，开源了context包。使用context包来实现上下文功能 …..
约定：需要在你的方法的传入参数的第一个参数是context.Context的变量。

2，context结构

使用例子（1）：

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.
    // 定义 goroutine 函数
    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() // main 方法执行完后，结束 ctx 相关的 goroutine
    for n := range gen(ctx) {
        fmt.Println(n)
        if n == 5 {
            break
        }
    }
}

使用例子（2）:

package main
import (
    "fmt"
    "time"
    "golang.org/x/net/context"
)
func Cdd(ctx context.Context) int {
    fmt.Println(ctx.Value("NLJB"))
    select {
    // 结束时候做点什么 ...
    case <-ctx.Done():
        return -3
    default:
        // 没有结束 ... 执行 ...
    }
}
func Bdd(ctx context.Context) int {
    fmt.Println(ctx.Value("HELLO"))
    fmt.Println(ctx.Value("WROLD"))
    ctx = context.WithValue(ctx, "NLJB", "NULIJIABEI")
    go fmt.Println(Cdd(ctx))
    select {
    // 结束时候做点什么 ...
    case <-ctx.Done():
        return -2
    default:
        // 没有结束 ... 执行 ...
    }
}
func Add(ctx context.Context) int {
    ctx = context.WithValue(ctx, "HELLO", "WROLD")
    ctx = context.WithValue(ctx, "WROLD", "HELLO")
    go fmt.Println(Bdd(ctx))
    select {
    // 结束时候做点什么 ...
    case <-ctx.Done():
        return -1
    default:
        // 没有结束 ... 执行 ...
    }
}
func main() {
    // 自动取消(定时取消)
    {
        timeout := 3 * time.Second
        ctx, _ := context.WithTimeout(context.Background(), timeout)
        fmt.Println(Add(ctx))
    }
    // 手动取消
    // { 
    // ctx, cancel := context.WithCancel(context.Background())
    // go func() { 
    // time.Sleep(2 * time.Second)
    // cancel() // 在调用处主动取消
    // }()
    // fmt.Println(Add(ctx))
    // }
    select {}
}

（1）context.Context 接口

context包里的方法是线程安全的，可以被多个线程使用
当Context被canceled或是timeout, Done返回一个被closed 的channel
在Done的channel被closed后, Err代表被关闭的原因
如果存在, Deadline 返回Context将要关闭的时间

如果存在，Value 返回与 key 相关了的值，不存在返回 nil

// context 包的核心
type Context interface {

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

}

Deadline会返回一个超时时间，Goroutine获得了超时时间后，例如可以对某些io操作设定超时时间。
Done方法返回一个信道（channel）。当Context被cancenl或timeout时，该信道被关闭。它是一个表示Context是否已关闭的信号。
当Done信道关闭后，Err方法表明Context被撤的原因。
Value可以让Goroutine共享一些数据，当然获得数据是协程安全的。但使用这些数据的时候要注意同步，比如返回了一个map，而这个map的读写则要加锁。

（2）接口的实现

我们不需要手动实现这个接口，context 包已经给我们提供了两个

Background
TODO

这两个函数都会返回一个Context的实例只是返回的这两个实例都是空 Context。

/* TODO返回一个非nil，empty的上下文 在目前还不清楚要使用的上下文或尚不可用时 */
context.TODO()
/* Background返回一个非nil，empty的上下文。 这是没有取消，没有值，并且没有期限。 它通常用于由主功能，初始化和测试，并作为输入的顶层上下文 */
context.Background()

3，context包里的方法

（1）方法的使用

Context接口没有提供方法来设置其值和过期时间，也没有提供方法直接将其自身撤销。也就是说，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 interface{}, val interface{}) Context

WithCancel 对应的是 cancelCtx ,其中，返回一个 cancelCtx ，同时返回一个 CancelFunc，CancelFunc 是 context 包中定义的一个函数类型：type CancelFunc func()。调用这个 CancelFunc 时，关闭对应的c.done，也就是让他的后代goroutine退出
WithDeadline 和 WithTimeout 对应的是 timerCtx ，WithDeadline 和 WithTimeout 是相似的，WithDeadline 是设置具体的 deadline 时间，到达 deadline 的时候，后代 goroutine 退出，而 WithTimeout 简单粗暴，直接 return WithDeadline(parent, time.Now().Add(timeout))
WithValue 对应 valueCtx ，WithValue 是在 Context 中设置一个 map，拿到这个 Context 以及它的后代的 goroutine 都可以拿到 map 里的值

Context 的调用应该是链式的，通过WithCancel，WithDeadline，WithTimeout或WithValue派生出新的 Context。当父 Context 被取消时，其派生的所有 Context 都将取消。

通过context.WithXXX都将返回新的 Context 和 CancelFunc。调用 CancelFunc 将取消子代，移除父代对子代的引用，并且停止所有定时器。未能调用 CancelFunc 将泄漏子代，直到父代被取消或定时器触发。go vet工具检查所有流程控制路径上使用 CancelFuncs。