Golang中Context包使用场景和示例详解-51CTO.COM

本文结合示例代码讲解一下context包的几种使用场景。

控制子协程退出

context包提供了一种机制，可以在多个goroutine之间进行通信和控制。使用Context包能够有效地控制程序的并发性，提高程序的健壮性和性能。

Golang是没有办法让其他goroutine退出的，goroutine只能自己退出。之所以说context包可以控制子协程退出意思是子协程可以接收到主协程发出的退出信号，然后自己退出。看如下示例代码：

package main

import (
	"context"
	"errors"
	"sync"
)

func request(ctx context.Context, url string) error {
	result := make(chan int)
	err := make(chan error)
	go func() {
		// 假如isSuccess是请求返回的结果，成功则通过result传递成功信息，错误通过error传递错误信息
		isSuccess := true
		if isSuccess {
			result <- 1
		} else {
			err <- errors.New("some error happen")
		}
	}()

	select {
	case <-ctx.Done():
		// 其他请求失败
		return ctx.Err()
	case e := <-err:
		// 本次请求失败，返回错误信息
		return e
	case <-result:
		// 本此请求成功，不返回错误信息
		return nil
	}
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	// 调用接口a
	err := request(ctx, "https://xxx.com/a")
	if err != nil {
		return
	}
	wg := sync.WaitGroup{}
	// 调用接口b
	wg.Add(1)
	go func() {
		defer wg.Done()
		err := request(ctx, "https://xxx.com/b")
		if err != nil {
			cancel()
		}
	}()
	// 调用接口c
	wg.Add(1)
	go func() {
		defer wg.Done()
		err := request(ctx, "https://xxx.com/c")
		if err != nil {
			cancel()
		}
	}()
	wg.Wait()
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.

首先调用context.WithCancel方法构造了一个Context和返回了一个cancel函数，其他goroutine调用的方法都传入了这个Context作为第一个参数，当主goroutine想要告诉所有goroutine需要退出的时候，通过调用cancel函数把退出的信息告诉所有的goroutine。所有goroutine通过监听ctx.Done返回的channel得到退出信号然后退出。

超时控制

例如查询数据库、调用RPC服务、调用HTTP接口等场景，这些操作都是阻塞的，如果一直不返回数据的话，会影响产品的用户体验。针对这些情况的解决方式通常是设置一个超时间，超过后自动取消操作。

使用context包中的WithDeadline和WithTimeout方法可以实现这个解决方法。先看如下例子：

package main

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

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
    defer cancel()

    select {
    case <-time.After(1 * time.Second):
        fmt.Println("overslept")
    case <-ctx.Done():
        fmt.Println(ctx.Err()) // 输出 "context deadline exceeded"
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

因为设置的超时时间是50毫秒，所以select会进入第二个case，会输出“context deadline exceeded”。

Golang的net/http包发起http请求的时候是实现了超时控制的，看如下代码：

package main

import (
	"context"
	"io"
	"log"
	"net/http"
	"time"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://www.baidu.com", nil)
	if err != nil {
		log.Fatal(err)
	}

	// 构造一个超时间为50毫秒的Context
	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
	defer cancel()
	req = req.WithContext(ctx)
	
	c := &http.Client{}
	res, err := c.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()
	out, err := io.ReadAll(res.Body)
	if err != nil {
		log.Fatal(err)
	}
	log.Println(string(out))
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.

执行后会输出“context deadline exceeded”，如果将context.WithTimeout方法的timeout参数调大一些，就可以看到正常的返回数据。

上下文传递数据

这个作用在链路追踪中非常重要，链路追踪需要将traceID层层往下传递，在服务间传递。

type traceIdKey struct{}{}

// 定义固定的Key
var TraceIdKey = traceIdKey{}

func ServeHTTP(w http.ResponseWriter, req *http.Request){
  // 首先从请求中获取到traceID
  traceId := getTraceIdFromRequest(req)
  // 将Key存入Context中
  ctx := context.WithValue(req.Context(), TraceIdKey, traceId)
  // 设置超时时间
  ctx = context.WithTimeout(ctx, time.Second)
  // 携带traceId发起rpc请求
  repResp := RequestRPC(ctx, ...)
  // 携带traceId查询DB
  dbResp := RequestDB(ctx, ...)
  // ...
}

func RequestRPC(ctx context.Context, ...) interface{} {
    // 获取traceid，在调用rpc时记录日志
    traceId, _ := ctx.Value(TraceIdKey)
    // 发起请求

    // ...
    return
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

接收到请求后，通过req获取到traceId并记录到Context中，在调用其他RPC服务和查询DB时，传入构造的Context。在后续代码中，可以通过Context拿到存入的traceId。