go context 讲解

　　控制并发有两种经典的方式，一种是WaitGroup，另一种就是Context，今天我就谈谈Context。

什么是WaitGroup

WaitGroup之前咱们在并发的时候介绍过，它是一种控制并发的方式，它的这种方式是控制多个goroutine同时完成。

func main() {
	var wg sync.WaitGroup
	wg.Add(2)
	go func() {
		time.Sleep(2*time.Second)
		fmt.Println("1号完成")
		wg.Done()
	}()
	go func() {
		time.Sleep(2*time.Second)
		fmt.Println("2号完成")
		wg.Done()
	}()
	wg.Wait()
	fmt.Println("好了，你们都干完了，放工")
}

　　这是一种控制并发的方式，这种尤为适用于，好多个goroutine协同作一件事情的时候，由于每一个goroutine作的都是这件事情的一部分，只有所有的goroutine都完成，这件事情才算是完成，这是等待的方式。一个很简单的例子，必定要例子中的2个goroutine同时作完，才算是完成，先作好的就要等着其余未完成的，全部的goroutine要都所有完成才能够。

在实际的业务种，咱们可能会有这么一种场景：须要咱们主动的通知某一个goroutine结束。好比咱们开启一个后台goroutine一直作事情，好比监控，如今不须要了，就须要通知这个监控goroutine结束，否则它会一直跑，就泄漏了。

　　chan通知

　　咱们都知道一个goroutine启动后，咱们是没法控制他的，大部分状况是等待它本身结束，那么若是这个goroutine是一个不会本身结束的后台goroutine呢？好比监控等，会一直运行的。

这种状况化，一直傻瓜式的办法是全局变量，其余地方经过修改这个变量完成结束通知，而后后台goroutine不停的检查这个变量，若是发现被通知关闭了，就自我结束。

这种方式也能够，可是首先咱们要保证这个变量在多线程下的安全，基于此，有一种更好的方式：chan + select 。

func main() {
	stop := make(chan bool)
	go func() {
		for {
			select {
			case <-stop:
				fmt.Println("监控退出，中止了...")
				return
			default:
				fmt.Println("goroutine监控中...")
				time.Sleep(2 * time.Second)
			}
		}
	}()
	time.Sleep(10 * time.Second)
	fmt.Println("能够了，通知监控中止")
	stop<- true
	//为了检测监控过是否中止，若是没有监控输出，就表示中止了
	time.Sleep(5 * time.Second)
}

　　有了以上的逻辑，咱们就能够在其余goroutine种，给stop chan发送值了，例子中是在main goroutine中发送的，控制让这个监控的goroutine结束。例子中咱们定义一个stop的chan，通知他结束后台goroutine。实现也很是简单，在后台goroutine中，使用select判断stop是否能够接收到值，若是能够接收到，就表示能够退出中止了；若是没有接收到，就会执行default里的监控逻辑，继续监控，只到收到stop的通知。

　　发送了stop<- true结束的指令后，我这里使用time.Sleep(5 * time.Second)故意停顿5秒来检测咱们结束监控goroutine是否成功。若是成功的话，不会再有goroutine监控中...的输出了；若是没有成功，监控goroutine就会继续打印goroutine监控中...输出。

　　这种chan+select的方式，是比较优雅的结束一个goroutine的方式，不过这种方式也有局限性，若是有不少goroutine都须要控制结束怎么办呢？若是这些goroutine又衍生了其余更多的goroutine怎么办呢？若是一层层的无穷尽的goroutine呢？这就很是复杂了，即便咱们定义不少chan也很难解决这个问题，由于goroutine的关系链就致使了这种场景很是复杂。

　　初识Context

　　上面说的这种场景是存在的，好比一个网络请求Request，每一个Request都须要开启一个goroutine作一些事情，这些goroutine又可能会开启其余的goroutine。因此咱们须要一种能够跟踪goroutine的方案，才能够达到控制他们的目的，这就是Go语言为咱们提供的Context，称之为上下文很是贴切，它就是goroutine的上下文。

下面咱们就使用Go Context重写上面的示例。

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go func(ctx context.Context) {
		for {
			select {
			case <-ctx.Done():
				fmt.Println("监控退出，中止了...")
				return
			default:
				fmt.Println("goroutine监控中...")
				time.Sleep(2 * time.Second)
			}
		}
	}(ctx)
	time.Sleep(10 * time.Second)
	fmt.Println("能够了，通知监控中止")
	cancel()
	//为了检测监控过是否中止，若是没有监控输出，就表示中止了
	time.Sleep(5 * time.Second)
}

　　

context.Background() 返回一个空的Context，这个空的Context通常用于整个Context树的根节点。而后咱们使用context.WithCancel(parent)函数，建立一个可取消的子Context，而后看成参数传给goroutine使用，这样就可使用这个子Context跟踪这个goroutine。重写比较简单，就是把原来的chan stop 换成Context，使用Context跟踪goroutine，以便进行控制，好比结束等。

在goroutine中，使用select调用<-ctx.Done()判断是否要结束，若是接受到值的话，就能够返回结束goroutine了；若是接收不到，就会继续进行监控。

那么是如何发送结束指令的呢？这就是示例中的cancel函数啦，它是咱们调用context.WithCancel(parent)函数生成子Context的时候返回的，第二个返回值就是这个取消函数，它是CancelFunc类型的。咱们调用它就能够发出取消指令，而后咱们的监控goroutine就会收到信号，就会返回结束。

　　Context控制多个goroutine

　　使用Context控制一个goroutine的例子如上，很是简单，下面咱们看看控制多个goroutine的例子，其实也比较简单。

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go watch(ctx,"【监控1】")
	go watch(ctx,"【监控2】")
	go watch(ctx,"【监控3】")
	time.Sleep(10 * time.Second)
	fmt.Println("能够了，通知监控中止")
	cancel()
	//为了检测监控过是否中止，若是没有监控输出，就表示中止了
	time.Sleep(5 * time.Second)
}
func watch(ctx context.Context, name string) {
	for {
		select {
		case <-ctx.Done():
			fmt.Println(name,"监控退出，中止了...")
			return
		default:
			fmt.Println(name,"goroutine监控中...")
			time.Sleep(2 * time.Second)
		}
	}
}

　　

　　《Go语言实战》读书笔记，未完待续，欢迎扫码关注公众号flysnow_org或者网站http://www.flysnow.org/，第一时间看后续笔记。以为有帮助的话，顺手分享到朋友圈吧，感谢支持。示例中启动了3个监控goroutine进行不断的监控，每个都使用了Context进行跟踪，当咱们使用cancel函数通知取消时，这3个goroutine都会被结束。这就是Context的控制能力，它就像一个控制器同样，按下开关后，全部基于这个Context或者衍生的子Context都会收到通知，这时就能够进行清理操做了，最终释放goroutine，这就优雅的解决了goroutine启动后不可控的问题。

　　Context接口

　　Context的接口定义的比较简洁，咱们看下这个接口的方法。

　　

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

　　Deadline方法是获取设置的截止时间的意思，第一个返回式是截止时间，到了这个时间点，Context会自动发起取消请求；第二个返回值ok==false时表示没有设置截止时间，若是须要取消的话，须要调用取消函数进行取消。这个接口共有4个方法，了解这些方法的意思很是重要，这样咱们才能够更好的使用他们。

Done方法返回一个只读的chan，类型为struct{}，咱们在goroutine中，若是该方法返回的chan能够读取，则意味着parent context已经发起了取消请求，咱们经过Done方法收到这个信号后，就应该作清理操做，而后退出goroutine，释放资源。

Err方法返回取消的错误缘由，由于什么Context被取消。

Value方法获取该Context上绑定的值，是一个键值对，因此要经过一个Key才能够获取对应的值，这个值通常是线程安全的。

以上四个方法中经常使用的就是Done了，若是Context取消的时候，咱们就能够获得一个关闭的chan，关闭的chan是能够读取的，因此只要能够读取的时候，就意味着收到Context取消的信号了，如下是这个方法的经典用法。

func Stream(ctx context.Context, out chan<- Value) error {
	for {
		v, err := DoSomething(ctx)
		if err != nil {
			return err
		}
		select {
		case <-ctx.Done():
			return ctx.Err()
		case out <- v:
		}
	}
}

　　　　

Context接口并不须要咱们实现，Go内置已经帮咱们实现了2个，咱们代码中最开始都是以这两个内置的做为最顶层的partent context，衍生出更多的子Context。

var (
	background = new(emptyCtx)
	todo       = new(emptyCtx)
)
func Background() Context {
	return background
}
func TODO() Context {
	return todo
}

　　一个是TODO,它目前还不知道具体的使用场景，若是咱们不知道该使用什么Context的时候，可使用这个。一个是Background，主要用于main函数、初始化以及测试代码中，做为Context这个树结构的最顶层的Context，也就是根Context。

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

type emptyCtx int
func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
	return
}
func (*emptyCtx) Done() <-chan struct{} {
	return nil
}
func (*emptyCtx) Err() error {
	return nil
}
func (*emptyCtx) Value(key interface{}) interface{} {
	return nil
}

　　

Context的继承衍生

这就是emptyCtx实现Context接口的方法，能够看到，这些方法什么都没作，返回的都是nil或者零值。

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

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函数，接收的都有一个partent参数，就是父Context，咱们要基于这个父Context建立出子Context的意思，这种方式能够理解为子Context对父Context的继承，也能够理解为基于父Context的衍生。

经过这些函数，就建立了一颗Context树，树的每一个节点均可以有任意多个子节点，节点层级能够有任意多个。

WithCancel函数，传递一个父Context做为参数，返回子Context，以及一个取消函数用来取消Context。
WithDeadline函数，和WithCancel差很少，它会多传递一个截止时间参数，意味着到了这个时间点，会自动取消Context，固然咱们也能够不等到这个时候，能够提早经过取消函数进行取消。

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

WithValue函数和取消Context无关，它是为了生成一个绑定了一个键值对数据的Context，这个绑定的数据能够经过Context.Value方法访问到，后面咱们会专门讲。

你们可能留意到，前三个函数都返回一个取消函数CancelFunc，这是一个函数类型，它的定义很是简单。

type CancelFunc func()

　　

WithValue传递元数据这就是取消函数的类型，该函数能够取消一个Context，以及这个节点Context下全部的全部的Context，无论有多少层级。

经过Context咱们也能够传递一些必须的元数据，这些数据会附加在Context上以供使用。

var key string="name"
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	//附加值
	valueCtx:=context.WithValue(ctx,key,"【监控1】")
	go watch(valueCtx)
	time.Sleep(10 * time.Second)
	fmt.Println("能够了，通知监控中止")
	cancel()
	//为了检测监控过是否中止，若是没有监控输出，就表示中止了
	time.Sleep(5 * time.Second)
}
func watch(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			//取出值
			fmt.Println(ctx.Value(key),"监控退出，中止了...")
			return
		default:
			//取出值
			fmt.Println(ctx.Value(key),"goroutine监控中...")
			time.Sleep(2 * time.Second)
		}
	}
}

　　

咱们可使用context.WithValue方法附加一对K-V的键值对，这里Key必须是等价性的，也就是具备可比性；Value值要是线程安全的。在前面的例子，咱们经过传递参数的方式，把name的值传递给监控函数。在这个例子里，咱们实现同样的效果，可是经过的是Context的Value的方式。

这样咱们就生成了一个新的Context，这个新的Context带有这个键值对，在使用的时候，能够经过Value方法读取ctx.Value(key)。

记住，使用WithValue传值，通常是必须的值，不要什么值都传递。

Context 使用原则

1. 不要把Context放在结构体中，要以参数的方式传递
2. 以Context做为参数的函数方法，应该把Context做为第一个参数，放在第一位。
3. 给一个函数方法传递Context的时候，不要传递nil，若是不知道传递什么，就使用context.TODO
4. Context的Value相关方法应该传递必须的数据，不要什么数据都使用这个传递
5. Context是县城安全的，能够放心的在多个goroutine中传递