【gogogo专栏】context包的使用

context包是干什么的？

在go语言中，经常会遇到goroutine之间的协作，在一般情况下，有些判断是否停止的操作，以及定时操作，停止获取结果操作等如果使用基础版可能会引入多个chan，操作较为复杂，于是go就帮我们封装了context来解决这些问题。

context的使用

我们先来看下context的几种基础使用。

WithCancel：带结束标志的context

以下面代码为例

func main() {
	ctx, clear := context.WithCancel(context.Background())
	message := make(chan string)
	go run(ctx, message)
	for i := 0; i < 10; i++ {
		message <- strconv.Itoa(i)
	}
	clear()
	time.Sleep(time.Second * 1)
	fmt.Println("主进程结束")
}

func run(ctx context.Context, message chan string) {
	tick := time.Tick(time.Second)
	for range tick {
		select {
		case m := <-message:
			fmt.Printf("接收数据 %s\n", m)
		case <-ctx.Done():
			fmt.Println("我结束了")
			return
		}
	}
}

正常情况下可能需要两个chan来进行线程协作，使用一个chan传入一个flag字段来判断协程是否结束，而context则封装了几种方法更加方便我们更好的使用协程。
当执行clear方法的时候，则向context传递结束标识，从而在协程中感知结束标记。

WithValue：带特定值的context

func main() {
	ctx := context.WithValue(context.Background(), "key", "结束")
	ctx, clear := context.WithCancel(ctx)
	message := make(chan string)
	go run(ctx, message)
	for i := 0; i < 10; i++ {
		message <- strconv.Itoa(i)
	}
	clear()
	time.Sleep(time.Second * 1)
	fmt.Println("主进程结束")
}

func run(ctx context.Context, message chan string) {
	tick := time.Tick(time.Second)
	for range tick {
		select {
		case m := <-message:
			fmt.Printf("接收数据 %s\n", m)
		case <-ctx.Done():
			fmt.Println(ctx.Value("key"))
			return
		}
	}
}

我们可以用WithValue将特定的值带入context，在协程里面可以获取特定的值，比如结束原因等。

WithDeadline：带截止时间的context

func main() {
	ctx, clear := context.WithDeadline(context.Background(), time.Now().Add(time.Second*5))
	message := make(chan string)
	go run(ctx, message)
	for i := 0; i < 10; i++ {
		message <- strconv.Itoa(i)
	}
	defer clear()
	time.Sleep(time.Second * 1)
	fmt.Println("主进程结束")
}

func run(ctx context.Context, message chan string) {
	tick := time.Tick(time.Second)
	for range tick {
		select {
		case m := <-message:
			fmt.Printf("接收数据 %s\n", m)
		case <-ctx.Done():
			fmt.Println("我结束了")
			return
		}
	}
}

可以定个时间来执行，保证到达时间结束。

WithTimeout：带延迟时间的context

func main() {
	ctx, clear := context.WithTimeout(context.Background(), time.Second*5)
	message := make(chan string)
	go run(ctx, message)
	for i := 0; i < 10; i++ {
		message <- strconv.Itoa(i)
	}
	defer clear()
	time.Sleep(time.Second * 1)
	fmt.Println("主进程结束")
}

func run(ctx context.Context, message chan string) {
	tick := time.Tick(time.Second)
	for range tick {
		select {
		case m := <-message:
			fmt.Printf("接收数据 %s\n", m)
		case <-ctx.Done():
			fmt.Println("我结束了")
			return
		}
	}
}

可以定个延迟时间，保证多少秒以后结束。

总结

总的来说，context包包含了很多方法来进行协程协程间的通信，可以帮助我们很好的完成多个协程的相互操作。