context
- 1 context包定义了上下文类型，跨越 API 边界和进程之间传递截止时间，取消信号,超时时间，传输值共享资源等。context 成为了并发控制和超时控制的标准做法
// 接口定义的4个方法
type Context interface{
Deadline() (deadline time.Time, ok bool) // 1返回被自动取消的时间
Done() <-chan struct{} // 2返回关闭的channel，单向的管道!
Err() error // 3在channel Done关闭后，返回context被取消的原因
Value(key interface{}) interface{} // 4获取Key对应的值
}
2 Done() 返回一个 channel，是一个只读的channel(单向只能读取!)，可以表示 context 被取消的信号：当这个 channel 被关闭时，说明 context 被取消了。Err() 返回一个错误，表示 channel 被关闭的原因。例如是被取消，还是超时。Deadline() 返回 context 的截止时间，通过此时间，函数就可以决定是否进行接下来的操作，如果时间太短，就可以不往下做了，否则浪费系统资源。当然，也可以用这个 deadline 来设置一个 I/O 操作的超时时间。Value() 获取之前设置的 key 对应的 value。
3 canceler 接口里定义了cancel()方法，但是却没有实现这个方法，操作是建议性，而非强制性。cancel()取消某个函数时，和它相关联的其他函数也应该取消cancel()。Done() 方法返回一个只读的 channel，所有相关函数监听此 channel。一旦 channel 关闭，通过 channel 的“广播机制”，所有监听者都能收到。
type canceler interface {
cancel(removeFromParent bool, err error)
Done() <-chan struct{}
}
- 4 Canceled 是上下文取消时 Context.Err 返回的错误提示。
var Canceled = errors.New("context canceled")
- 5 DeadlineExceeded 是Context.Err 在上下文截止时间过后返回的错误
var DeadlineExceeded error = deadlineExceededError{}
- 6 源码中定义的emptyCtx类型实现了Context接口，但却是一个空的接口，没有返回任何数据，这实际上是一个空的 context，永远不会被 cancel，没有存储值，也没有 deadline。background 通常用在 main 函数中，作为所有 context 的根节点。todo 就相当于一个占位符，在不知道传什么context的时候可以用它来占个位子，最终要换成其他 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
}
// 被包装成下面这样对外输出!!
var (
background = new(emptyCtx)
todo = new(emptyCtx)
)
func Background() Context {
return background
}
func TODO() Context {
return todo
}
- 7 cancel() 方法的实现是关闭channel()；递归地取消它的所有子节点，释放相关资源，并且从父节点中删除自己，通过关闭 channel，将取消信号传递给了它的所有子节点。goroutine 接收到取消信号的方式就是 select 语句中的读 c.done 被选中。
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
if err == nil {
panic("context: internal error: missing cancel error")
}
c.mu.Lock()
if c.err != nil {
c.mu.Unlock()
return
}
c.err = err
if c.done == nil {
c.done = closedchan
} else {
close(c.done)
}
// 遍历所有子节点，递归的取消所有子节点!
for child := range c.children {
child.cancel(false, err)
}
c.children = nil
c.mu.Unlock()
if removeFromParent {
removeChild(c.Context, c) //从父节点中删除自己
}
}
- 8 WithDeadline() 返回的是父的上下文副本，截止日期到期，返回的取消功能被调用时,或者父上下文的完成通道关闭时，返回的上下文的完成通道将关闭，以先发生者为准。取消这个上下文会释放与它相关资源，只要完成在这个Context 中运行的操作，代码就应该调用cancel()。
// 源码！！
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
}
// =====那个时间小就会先执行那个case,通过设定时间来取消上下文操作!=====
func main() {
d := time.Now().Add(50 * time.Millisecond)
ctx, cancel := context.WithDeadline(context.Background(), d)
defer cancel()
select {
case <-time.After(1 * time.Second):
fmt.Println("overslept")
case <-ctx.Done():
fmt.Println(ctx.Err()) //返回取消的原因!
}
}
- 9 WithCancel 返回一个新的父级的上下文副本，返回的上下文Done()通道关闭时，取消这个上下文会释放相关资源。Demo取消上下文防止goroutine泄露。
-- demo :
func main() {
g := func(ctx context.Context) <-chan int {
d := make(chan int)
n := 1
go func() {
for {
select {
case <-ctx.Done():
return // 返回不要泄漏goroutine
case dst <- n:
n++
}
}
}()
return d
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel() // 当我们完成消耗整数时取消
for n := range g(ctx) {
fmt.Println(n)
if n == 5 {
break
}
fmt.Println(n)// 1 2 3 4
}
}
- 10 WithTimeout 取消这个上下文可以释放与它相关的资源，因此只要在这个Context 中运行的操作完成，代码就应该立即调用 cancel
// 源码!
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
return WithDeadline(parent, time.Now().Add(timeout))
}
11 WithValue 创建 context 节点的过程实际上就是创建链表节点的过程。两个节点的 key 值是可以相等的，但它们是两个不同的 context 节点。查找的时候，会向上查找到最后一个挂载的 context 节点，也就是离得比较近的一个父节点 context。所以，整体上而言，用 WithValue 构造的其实是一个低效率的链表。
12 像 WithCancel、WithDeadline、WithTimeout、WithValue 这些创建函数，实际上是创建了一个个的链表结点
func WithValue(parent Context, key, val interface{}) Context {
if parent == nil {
panic("cannot create context from nil parent")
}
if key == nil {
panic("nil key")
}
if !reflectlite.TypeOf(key).Comparable() {
panic("key is not comparable")
}
return &valueCtx{parent, key, val}
}
type valueCtx struct {
Context
key, val interface{}
}
...
func (c *valueCtx) Value(key interface{}) interface{} {
if c.key == key {
return c.val
}
return c.Context.Value(key)
}
总结
- 1 WithValue 就是依赖一个Key来作为标识而取消上下文
func main() {
type Key string
f:=func(ctx context.Context, k Key) {
if v := ctx.Value(k);v!=nil{
fmt.Println("found value",v)
return
}
fmt.Println("key not found",k)
}
ctx := context.WithValue(context.Background(),"la", "GO")
k:=Key("la")
f(ctx,k)
f(ctx,Key("color"))
}
- 2 WithDeadline 设定的截止日期一到就执行退出取消上下文
func main() {
// 2个时间比较，那个时间执行最先就先执行那个退出取消!
t:=time.Now().Add(50*time.Millisecond)
// WithDeadline设定的截止日期一到就执行!
ctx, cancel := context.WithDeadline(context.Background(), t)
defer cancel() //当你取消这个上下文时，所有占用的资源都将被释放！
select{
case <- time.After(1*time.Second):
fmt.Println("over")
case <- ctx.Done():
fmt.Println(222,ctx.Err())
}
}
3 WithTimeout 跟WithDeadline 很像，设定一个时间，管道只要监听到有时间到了就执行退出取消
4 WithCancel 接收一个新的上下文context，只要执行cancel()方法后，监听的管道才会退出取消上下文! 跟WithDeadline，WithTimeout 比较，少了个参数，WithCancel不需要其他或者标识来作为判断依据，只要监听到管道有取消信号立马退出!
var a = 0
func f1(i int)error{
a++
fmt.Println(a)
if a>3{
return errors.New("cancel context")
}
return nil
}
func main() {
ctx,cancel := context.WithCancel(context.Background())
go f3(ctx,cancel)
time.Sleep(time.Second*1)
}
func f3(ctx context.Context, cancel context.CancelFunc){
for{
select{
// 因为没有监听到管道里的取消信号，所以开始没有走这一步 !
case <- ctx.Done():
fmt.Println("context done")
return
default:
info:=f1(3)
if info!=nil{
fmt.Println(222,info)
cancel()
}
}
}
}
