大佬教程收集整理的这篇文章主要介绍了context包,大佬教程大佬觉得挺不错的,现在分享给大家,也给大家做个参考。
我们会在用到很多东西的时候都看到context的影子,比如gin框架,比如grpc,这东西到底是做啥的? 大家都在用,没几个知道这是干嘛的,知其然而不知其所以然
原理说白了就是:
这就是context包的核心原理,链式传递context,基于context构造新的context
package main
import (
"context"
"fmt"
"time"
)
func main() {
ctx, cancel := context.WithCancel(context.Background())
//缓冲通道预先放置10个消息
messages := make(chan int, 10)
defer close(messages)
for i := 0; i < 10; i++ {
messages <- i
}
//启动3个子协程消费messages消息
for i := 1; i <= 3; i++ {
go child(i, ctx, messages)
}
time.Sleep(3 * time.Second) //等待子协程接收一半的消息
cancel() //结束前通知子协程
time.Sleep(2 * time.Second) //等待所有的子协程输出
fmt.Println("主协程结束")
}
//从messages通道获取信息,当收到结束信号的时候不再接收
func child(i int, ctx context.Context, messages <-chan int) {
//基于父级的context建立context
newCtx, _ := context.WithCancel(ctx)
go childJob(i, "a", newCtx)
go childJob(i, "b", newCtx)
Consume:
for {
time.Sleep(1 * time.Second)
select {
case <-ctx.Done():
fmt.Printf("[%d]被主协程通知结束...n", i)
break Consume
default:
fmt.Printf("[%d]接收消息: %dn", i, <-messages)
}
}
}
//任务
func childJob(parent int, name string, ctx context.Context) {
for {
time.Sleep(1 * time.Second)
select {
case <-ctx.Done():
fmt.Printf("[%d-%v]被结束...n", parent, name)
return
default:
fmt.Printf("[%d-%v]执行n", parent, name)
}
}
}
运行结果如下
可以看到,改成context包还是顺利的通过子协程退出了 主要修改了几个地方,再ctx向下传递
基于上层context再构建当前层级的context
监听context的退出信号,
这就是context包的核心原理,链式传递context,基于context构造新的context
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <-chan struct{}
Err() error
Value(key interface{}) interface{}
}
Deadline返回绑定当前context的任务被取消的截止时间;如果没有设定期限,将返回ok == false。
Done 当绑定当前context的任务被取消时,将返回一个关闭的channel;如果当前context不会被取消,将返回nil。
Err 如果Done返回的channel没有关闭,将返回nil;如果Done返回的channel已经关闭,将返回非空的值表示任务结束的原因。如果是context被取消,Err将返回Canceled;如果是context超时,Err将返回DeadlineExceeded。
Value 返回context存储的键值对中当前key对应的值,如果没有对应的key,则返回nil。
实现了context接口,emptyCtx没有超时时间,不能取消,也不能存储额外信息,所以emptyCtx用来做根节点,一般用Background和TODO来初始化emptyCtx
通常用于主函数,初始化以及测试,作为顶层的context
context.Background()
不确定使用什么用context的时候才会使用
type valueCtx struct{ Context key, val interface{} }
valueCtx利用Context的变量来表示父节点context,所以当前context继承了父context的所有信息 valueCtx还可以存储键值。
可以向context添加键值
func WithValue(parent Context, key, val interface{}) Context {
if key == nil {
panic("nil key")
}
if !reflect.TypeOf(key).Comparable() {
panic("key is not comparable")
}
return &valueCtx{parent, key, val}
}
添加键值会返回创建一个新的valueCtx子节点
func (c *valueCtx) Value(key interface{}) interface{} {
if c.key == key {
return c.val
}
return c.Context.Value(key)
}
可以用来获取当前context和所有的父节点存储的key
如果当前的context不存在需要的key,会沿着context链向上寻找key对应的值,直到根节点
package main
import (
"context"
"fmt"
"time"
)
func main() {
ctx := context.WithValue(context.Background(), "name1", "root1")
//第一层
go func(parent context.Context) {
ctx = context.WithValue(parent, "name2", "root2")
//第二层
go func(parent context.Context) {
ctx = context.WithValue(parent, "name3", "root3")
//第三层
go func(parent context.Context) {
//可以获取所有的父类的值
fmt.Println(ctx.Value("name1"))
fmt.Println(ctx.Value("name2"))
fmt.Println(ctx.Value("name3"))
//不存在
fmt.Println(ctx.Value("name4"))
}(ctx)
}(ctx)
}(ctx)
time.Sleep(1 * time.Second)
fmt.Println("end")
}
运行结果
可以看到,子context是可以获取所有父级设置过的key
用来创建一个可取消的context,返回一个context和一个CancelFunc,调用CancelFunc可以触发cancel操作。
package main
import (
"context"
"fmt"
"time"
)
func main() {
ctx, cancel := context.WithCancel(context.Background())
//第一层
go func(parent context.Context) {
ctx, _ := context.WithCancel(parent)
//第二层
go func(parent context.Context) {
ctx, _ := context.WithCancel(parent)
//第三层
go func(parent context.Context) {
waitCancel(ctx, 3)
}(ctx)
waitCancel(ctx, 2)
}(ctx)
waitCancel(ctx, 1)
}(ctx)
// 主线程给的结束时间
time.Sleep(2 * time.Second)
cancel() // 调用取消context
time.Sleep(1 * time.Second)
}
func waitCancel(ctx context.Context, i int) {
for {
time.Sleep(time.Second)
select {
case <-ctx.Done():
fmt.Printf("%d endn", i)
return
default:
fmt.Printf("%d don", i)
}
}
}
结果:
type cancelCtx struct {
Context
mu sync.Mutex
done chan struct{}
children map[canceler]struct{}
err error
}
type canceler interface {
cancel(removeFromParent bool, err error)
Done() <-chan struct{}
}
返回一个基于parent的可取消的context,并且过期时间deadline不晚于所设置时间d
创建一个定时取消context,和WithDeadline差不多,WithTimeout是相对时间
timerCtx是基于cancelCtx的context精英,是一种可以定时取消的context,过期时间的deadline不晚于所设置的时间d
示例:
package main
import (
"context"
"fmt"
"time"
)
func main() {
// 设置超时时间
ctx, _ := context.WithTimeout(context.Background(), 2*time.Second)
//第一层
go func(parent context.Context) {
ctx, _ := context.WithCancel(parent)
//第二层
go func(parent context.Context) {
ctx, _ := context.WithCancel(parent)
//第三层
go func(parent context.Context) {
waitCancel(ctx, 3)
}(ctx)
waitCancel(ctx, 2)
}(ctx)
waitCancel(ctx, 1)
}(ctx)
<-ctx.Done()
// 给时间调用end
time.Sleep(time.Second)
}
func waitCancel(ctx context.Context, i int) {
for {
time.Sleep(time.Second)
select {
case <-ctx.Done():
fmt.Printf("%d endn", i)
return
default:
fmt.Printf("%d don", i)
}
}
}
运行结果:
1 do
3 do
2 do
1 end
3 end
2 end
可以看到,虽然我们没有调用cancel方法,5秒后自动调用了,所有的子goroutine都已经收到停止信号
res,ok := <-done:
c.timer = time.AfterFunc(dur, func() {
c.cancel(true, DeadlineExceeded)
})
以上是大佬教程为你收集整理的context包全部内容,希望文章能够帮你解决context包所遇到的程序开发问题。
如果觉得大佬教程网站内容还不错,欢迎将大佬教程推荐给程序员好友。
本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ:384754419,请注明来意。