参考
context 接口介绍
Context被称之为上下文,用它我们可以,它可以实时跟踪我们的每一个Go协程,有了这个特性,我们只需要了解怎么使用就可以了。
context接口如下:
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <-chan struct{}
Err() error
Value(key interface{}) interface{}
}
- Deadline方法会返回设置的截止时间,如果协程运行到了这个时间点,Context则会自动触发取消,实现协程的关闭。
- Done方法是一个只读的通道,它意味着如果可以读,则说明我们的context发起的取消。
- Err()方法是在运营中出现错误会及时的返回
- Value()方法则可以在跟踪协程是带上key-value的值。
基础测试
验证 ctx.Done() 可收到结束信号,从而实现程序的退出控制
- 首先我们使用了context.Backgroud()创建了一个上下文根节点,这个根节点的值时空的
- 利用WithTimeout()基于根节点创建了一个【2s后自动取消的】上下文
- 创建一个 ticker 500 ms 定时器,可以自行添加逻辑探测程序是否存活
- 最后 2s 时间到了,<-ctx.Done() 收到信号,程序结束
func main() {
ctx, _ := context.WithTimeout(context.Background(), 2*time.Second)
startTime := time.Now()
// 并没有使用,现实中,可以用来接收 如查询数据库传来的数据
query := make(chan int)
// 定时器 每 500 ms 触发一次
ticker := time.NewTicker(500 * time.Millisecond)
for {
select {
case <-ctx.Done():
fmt.Println("收到了停止信号,超时结束")
cost := int(time.Since(startTime) / time.Second)
fmt.Println("用时:", cost, "s")
return
case <-query:
fmt.Println("读取数据")
case <-ticker.C:
fmt.Println("探活,每 500 ms 检查一次")
}
}
}
控制协程
控制单个协程
使用 ctx.Done() 可控制协程的结束
- 首先我们使用了context.Backgroud()创建了一个上下文根节点,这个根节点的值时空的
- 利用WithCancel()基于根节点创建了一个可以取消的上下文,在go协程中我们使用了这个上下文来进行跟踪
- 利用select判断是否<-ctx.Done收到了取消的信号
- 使用 time.Sleep(5 * time.Second) 保证 main 进程一直在运行中,使 goroutine 一直运行
func main() {
ctx, cancel := context.WithCancel(context.Background())
go func(ctx context.Context) {
for {
select {
case <-ctx.Done():
fmt.Println("查询到有协程停止")
return
default:
fmt.Println("gorouting正在有效时间内运行")
time.Sleep(2 * time.Second)
}
}
}(ctx)
time.Sleep(20 * time.Second)
// 关闭 ctx,此时ctx.Done()会收到停止信号
cancel()
// 为了保证 main 主进程在运行中,若 main 函数结束, goroutine 会自动退出的
time.Sleep(5 * time.Second)
}
控制多个协程
只需要发一次信号,即可控制多个协程的结束
在这个事例中,共启动了3个协程,这3个协程,分别都用了一个Context上下文进行跟踪,此时如果cancel函数被使用,3个协程都均会关闭,所以,上下文不仅能关联一个协程,同时也能控制多个协程的关闭。
func main() {
ctx, cancel := context.WithCancel(context.Background())
go Run(ctx, "协程1")
go Run(ctx, "协程2")
go Run(ctx, "协程3")
time.Sleep(10 * time.Second)
fmt.Println("开始取消协程的运行")
cancel()
//为了检测监控过是否停止,如果没有监控输出,就表示停止了
time.Sleep(5 * time.Second)
}
func Run(ctx context.Context, name string) {
for {
select {
case <-ctx.Done():
fmt.Println(name, "收到结束信号,停止")
return
default:
fmt.Println(name, "goroutine 正在有效时间内运行")
time.Sleep(2 * time.Second)
}
}
}
// Output:
// 协程2 goroutine 正在有效时间内运行
// 协程1 goroutine 正在有效时间内运行
// 协程3 goroutine 正在有效时间内运行
// 开始取消协程的运行
// 协程3 收到结束信号,停止
// 协程2 收到结束信号,停止
// 协程1 收到结束信号,停止
Context的继承衍生
在上面的事例中我们均用到了一个函数那就是context.Background(),其实在context包中,不仅仅只提供了这一个函数来提供创建空根节点,还有一个叫做TODO的函数,这个函数和Background一样 都是一个结构体,且他们的特点都是不可取消,没有截止时间,也没有携带任何的Contxet,所以也可以被用作根节点。
有了如上的根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()
这就是取消函数的类型,该函数可以取消一个Context,以及这个节点Context下所有的所有的Context,不管有多少层级。
WithValue传递元数据
通过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)
}
}
}
在前面的例子,我们通过传递参数的方式,把name
的值传递给监控函数。在这个例子里,我们实现一样的效果,但是通过的是Context的Value的方式。
我们可以使用context.WithValue
方法附加一对K-V的键值对,这里Key必须是等价性的,也就是具有可比性;Value值要是线程安全的。
这样我们就生成了一个新的Context,这个新的Context带有这个键值对,在使用的时候,可以通过Value
方法读取ctx.Value(key)
。
记住,使用WithValue传值,一般是必须的值,不要什么值都传递。
Context 使用原则
- 不要把Context放在结构体中,要以参数的方式传递
- 以Context作为参数的函数方法,应该把Context作为第一个参数,放在第一位。
- 给一个函数方法传递Context的时候,不要传递nil,如果不知道传递什么,就使用context.TODO
- Context的Value相关方法应该传递必须的数据,不要什么数据都使用这个传递
- Context是线程安全的,可以放心的在多个goroutine中传递