Golang中context使用总结

Context背景 和 适用场景

golang在1.6.2的时候还没有自己的context，在1.7的版本中就把golang.org/x/net/context包被加入到了官方的库中。golang 的 Context包，是专门用来简化对于处理单个请求的多个goroutine之间与请求域的数据、取消信号、截止时间等相关操作，这些操作可能涉及多个 API 调用。

比如有一个网络请求Request，每个Request都需要开启一个goroutine做一些事情，这些goroutine又可能会开启其他的goroutine。这样的话， 我们就可以通过Context，来跟踪这些goroutine，并且通过Context来控制他们的目的，这就是Go语言为我们提供的Context，中文可以称之为“上下文”。

另外一个实际例子是，在Go服务器程序中，每个请求都会有一个goroutine去处理。然而，处理程序往往还需要创建额外的goroutine去访问后端资源，比如数据库、RPC服务等。由于这些goroutine都是在处理同一个请求，所以它们往往需要访问一些共享的资源，比如用户身份信息、认证token、请求截止时间等。而且如果请求超时或者被取消后，所有的goroutine都应该马上退出并且释放相关的资源。这种情况也需要用Context来为我们取消掉所有goroutine

Context 定义

ontext的主要数据结构是一种嵌套的结构或者说是单向的继承关系的结构，比如最初的context是一个小盒子，里面装了一些数据，之后从这个context继承下来的children就像在原本的context中又套上了一个盒子，然后里面装着一些自己的数据。或者说context是一种分层的结构，根据使用场景的不同，每一层context都具备有一些不同的特性，这种层级式的组织也使得context易于扩展，职责清晰。

context 包的核心是 struct Context，声明如下：

Deadline()返回一个time.Time，是当前 Context 的应该结束的时间，ok 表示是否有 deadline
Done()返回一个struct{}类型的只读 channel
Err()返回 Context 被取消时的错误
Value(key interface{}) 是 Context 自带的 K-V 存储功能

Context 的实现方法

Context 虽然是个接口，但是并不需要使用方实现，golang内置的context 包，已经帮我们实现了2个方法，一般在代码中，开始上下文的时候都是以这两个作为最顶层的parent context，然后再衍生出子context。这些 Context 对象形成一棵树：当一个 Context 对象被取消时，继承自它的所有 Context 都会被取消。两个实现如下：

一个是Background，主要用于main函数、初始化以及测试代码中，作为Context这个树结构的最顶层的Context，也就是根Context，它不能被取消。

一个是TODO，如果我们不知道该使用什么Context的时候，可以使用这个，但是实际应用中，暂时还没有使用过这个TODO。

他们两个本质上都是emptyCtx结构体类型，是一个不可取消，没有设置截止时间，没有携带任何值的Context。

Context 的 继承

有了如上的根Context，那么是如何衍生更多的子Context的呢？这就要靠context包为我们提供的With系列的函数了。

通过这些函数，就创建了一颗Context树，树的每个节点都可以有任意多个子节点，节点层级可以有任意多个。

WithCancel函数，传递一个父Context作为参数，返回子Context，以及一个取消函数用来取消Context。

WithDeadline函数，和WithCancel差不多，它会多传递一个截止时间参数，意味着到了这个时间点，会自动取消Context，当然我们也可以不等到这个时候，可以提前通过取消函数进行取消。

WithTimeout和WithDeadline基本上一样，这个表示是超时自动取消，是多少时间后自动取消Context的意思。

WithValue函数和取消Context无关，它是为了生成一个绑定了一个键值对数据的Context，这个绑定的数据可以通过Context.Value方法访问到，这是我们实际用经常要用到的技巧，一般我们想要通过上下文来传递数据时，可以通过这个方法，如我们需要tarce追踪系统调用栈的时候。

With 系列函数使用

package main
import (
	"context"
	"fmt"
	"io/ioutil"
	"net/http"
	"time"
)
type Result struct {
	r     *http.Response
	err   error
}
// WithTimeout超时自动取消
func process() {
	ctx,cancel :=context.WithTimeout(context.Background(),5*time.Second)
	//释放资源
	defer cancel()
	tr := &http.Transport{}
	client :=&http.Client{Transport: tr}
	resultChan :=make(chan Result,1)
	//建立连接，发起请求
	//req, err :=http.NewRequest("GET","http://www.baidu.com",nil)
	req, err :=http.NewRequest("GET","http://google.com",nil)
	if err != nil {
		fmt.Println("http request failed,err:",err)
		return
	}
	//5秒后取消这个协程
    go func() {
		resp, err :=client.Do(req)
		pack := Result{r: resp, err: err}
		//将返回的信息写入管道
		resultChan <- pack
	}()
	select{
case <-ctx.Done():
	tr.CancelRequest(req)
	er := <-resultChan
	fmt.Println("Timeout!",er.err)
case res := <-resultChan:
	defer res.r.Body.Close()
	out,_ :=ioutil.ReadAll(res.r.Body)
	fmt.Printf("Server Response: %s", out)
}
return
}
// WithValue绑定键值对
func process1(ctx1 context.Context) {
	ret,ok :=ctx1.Value("trace_id").(int)
	if !ok{
		ret =2222
	}
	fmt.Printf("ret:%d\n",ret)
	s , _ :=ctx1.Value("session").(string)
	fmt.Printf("session:%s\n",s)
}
// 截止时间
func process2() {
	d :=time.Now().Add(4 * time.Second)
	//4S后触发
	ctx , cancel :=context.WithDeadline(context.Background(),d)
	defer cancel()
	select {
	case <- time.After(5 * time.Second):
		fmt.Println("overslept!")
	case <- ctx.Done():
		fmt.Println(ctx.Err())
	}
}
// 利用withcancel结束goroutine
/*
 创建一个管道chan，启动goroutine
 for循环存数据
**/
func gen(ctx context.Context) <-chan int {
	dst := make(chan int)
	n :=1
	go func() {
		for {
			select {
			case <-ctx.Done():
				//执行defer cancel操作，就会执行该select入库
				fmt.Println("i exited!")
				return
			case dst <- n:
			n ++
			}
		}
	}()
	return dst
}
func test() {
	ctx3, cancel :=context.WithCancel(context.Background())
	defer cancel()
	intChan :=gen(ctx3)
	for n := range intChan {
		fmt.Println(n)
		if n == 5 {
			break
		}
	}
}

func main() {
	process()
	ctx1 :=context.WithValue(context.Background(),"trace_id",123456789)
	ctx1 = context.WithValue(ctx1,"session","ming")
	process1(ctx1)
	process2()
	test()
	
	time.Sleep(time.Hour)
	
}