Context包到底是干嘛用的?

我们会在用到很多东西的时候都看到context的影子,比如gin框架,比如grpc,这东西到底是做啥的?

大家都在用,没几个知道这是干嘛的,知其然而不知其所以然

原理说白了就是:

  1. 当前协程取消了,可以通知所有由它创建的子协程退出
  2. 当前协程取消了,不会影响到创建它的父级协程的状态
  3. 扩展了额外的功能:超时取消、定时取消、可以和子协程共享数据

context原理

这就是context包的核心原理,链式传递context,基于context构造新的context

什么时候应该使用 Context?

  • 每一个 RPC 调用都应该有超时退出的能力,这是比较合理的 API 设计
  • 不仅仅 是超时,你还需要有能力去结束那些不再需要操作的行为
  • context.Context 是 Go 标准的解决方案
  • 任何函数可能被阻塞,或者需要很长时间来完成的,都应该有个 context.Context

如何创建 Context?

  • 在 RPC 开始的时候,使用 context.Background()

    • 有些人把在 main() 里记录一个 context.Background(),然后把这个放到服务器的某个变量里,然后请求来了后从这个变量里继承 context。这么做是不对的。直接每个请求,源自自己的 context.Background() 即可。
  • 如果你没有 context,却需要调用一个 context 的函数的话,用 context.TODO()
  • 如果某步操作需要自己的超时设置的话,给它一个独立的 sub-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]接收消息: %d\n", 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

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。

emptyCtx结构体

实现了context接口,emptyCtx没有超时时间,不能取消,也不能存储额外信息,所以emptyCtx用来做根节点,一般用Background和TODO来初始化emptyCtx

Backgroud

通常用于主函数,初始化以及测试,作为顶层的context

context.Background()

TODO

不确定使用什么用context的时候才会使用

valueCtx结构体

type valueCtx struct{ Context key, val interface{} }

valueCtx利用Context的变量来表示父节点context,所以当前context继承了父context的所有信息

valueCtx还可以存储键值。

WithValue向context添加值

可以向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子节点

Value向context取值

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

WithCancel可取消的context

用来创建一个可取消的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 end\n", i)
return
default:
fmt.Printf("%d do\n", i)
}
}
}

结果:

cancelCtx结构体

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{}
}

WithDeadline-超时取消context

返回一个基于parent的可取消的context,并且过期时间deadline不晚于所设置时间d

WithTimeout-超时取消context

创建一个定时取消context,和WithDeadline差不多,WithTimeout是相对时间

timerCtx结构体

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 end\n", i)
return
default:
fmt.Printf("%d do\n", i)
}
}
}

运行结果:

1 do
3 do
2 do
1 end
3 end
2 end

可以看到,虽然我们没有调用cancel方法,5秒后自动调用了,所有的子goroutine都已经收到停止信号

总结核心原理

  1. Done方法返回一个channel
  2. 外部通过调用<-channel监听cancel方法
  3. cancel方法会调用close(channel)

    当调用close方法的时候,所有的channel再次从通道获取内容,会返回零值和false
res,ok := <-done:
  1. 过期自动取消,使用了time.AfterFunc方法,到时调用cancel方法
  c.timer = time.AfterFunc(dur, func() {
c.cancel(true, DeadlineExceeded)
})

context包的更多相关文章

  1. go使用context包避免goroutine泄露问题

    go是带内存自动回收的特性,因此内存一般不会泄漏.但是Goroutine确存在泄漏的情况,同时泄漏的Goroutine引用的内存同样无法被回收. 下面的程序中后台Goroutine向管道输入自然数序列 ...

  2. golang中的context包

    标准库的context包 从设计角度上来讲, golang的context包提供了一种父routine对子routine的管理功能. 我的这种理解虽然和网上各种文章中讲的不太一样, 但我认为基本上还是 ...

  3. Golang context包解读

    Context 通常被译作 上下文 ,一般理解为程序单元的一个运行状态.现场.快照,而翻译中 上下 又很好地诠释了其本质,上下上下则是存在上下层的传递, 上 会把内容传递给 下 . 在Go语言中,程序 ...

  4. golang中context包学习

    摘要 go语言中goroutine之间的关联关系,缺乏维护,在erlang中有专门的机制来保障新开仟程的生命周期, 在go语言中,只能通过channel + select来实现,但不够直观,感觉很绕. ...

  5. Golang Context 包详解

    Golang Context 包详解 0. 引言 在 Go 语言编写的服务器程序中,服务器通常要为每个 HTTP 请求创建一个 goroutine 以并发地处理业务.同时,这个 goroutine 也 ...

  6. Go语言的context包从放弃到入门

    目录 一.Context包到底是干嘛用的 二.主协程退出通知子协程示例演示 主协程通知子协程退出 主协程通知有子协程,子协程又有多个子协程 三.Context包的核心接口和方法 context接口 e ...

  7. golang context包

    go context标准库 context包在Go1.7版本时加入到标准库中.其设计目标是给Golang提供一个标准接口来给其他任务发送取消信号和传递数据.其具体作用为: 可以通过context发送取 ...

  8. golang 之 context包

    概述     context是Go中广泛使用的程序包,由Google官方开发,在1.7版本引入.它用来简化在多个go routine传递上下文数据.(手动/超时)中止routine树等操作,比如,官方 ...

  9. go context包的WithTimeout和WithCancel的使用

    1.WaitGroup 它是一种控制并发的方式,它的这种方式是控制多个goroutine同时完成. func main() { var wg sync.WaitGroup wg.Add(2) go f ...

随机推荐

  1. 《你不知道的JavaScript》整理(一)——作用域、提升与闭包

    最近在读一本进阶的JavaScript的书<你不知道的JavaScript(上卷)>,里面分析了很多基础性的概念. 可以更全面深入的理解JavaScript深层面的知识点. 一.函数作用域 ...

  2. Python入门学习笔记

    了解 一下Python中的基本语法,发现挺不适应的,例如变量经常想去指定类型或者if加个括号之类的.这是在MOOC中学习到的知识中一点简单的笔记. Python的变量和数据类型: 1.Python这种 ...

  3. container_of宏定义分析---linux内核

    问题:如何通过结构中的某个变量获取结构本身的指针??? 关于container_of宏定义在[include/linux/kernel.h]中:/*_** container_of - cast a ...

  4. android中利用view画出一条竖线

    在android中有时候需要通过线条来分割控件.最常见的情形就是在底部选项卡的多个button中间,通过加入一条竖线加以区分或者是在头部导航添加 竖线,将返回键和其他内容区分开来.一般会通过image ...

  5. 【转】 一个fork的面试题

    转自:一个fork的面试题 前两天有人问了个关于Unix的fork()系统调用的面试题,这个题正好是我大约十年前找工作时某公司问我的一个题,我觉得比较有趣,写篇文章与大家分享一下.这个题是这样的: 题 ...

  6. Presto向分区表快速插入数据时出现&#39;target directory already exists&#39;的原因

    因为项目使用Presto作为ETL使用,需要将关系库中的数据导入到Hive中.目前关系库中的数据每天导入一次,在Hive中以天为间隔创建新的分区.思路是正确的,但是在使用的过程中,发现将少量关系库中的 ...

  7. swift中的AnyHashable

    AnyHashable是调和objc和Swift的产物 典型的场景是,objc下无泛型的NSDictionary到了Swift下,会变成什么?(典型例子是苹果来的推送消息) [Any: Any],这肯 ...

  8. Java全栈程序员之03:Ubuntu下安装idea

    JetBrains的产品我曾经用过很长一段时间,它们是resharper和dotcover.VS号称宇宙最强IDE,直到它遇到了resharper,我们才知道,原来vs可以更好.DotCover是一个 ...

  9. mipmap和drawable文件夹的区别

    在Android上创建工程,会默认创建mipmap文件夹.之前在Eclipse上创建的是drawable的文件夹.那么这两个有什么区别呢? 问题: I'm working with android s ...

  10. Ubuntu图形界面环境下启动应该程序:

    1.先说下Ubuntu14.04系统开机紫框的问题: Grub theme:黑色屏幕出现紫色边框 There's a minor typo on the grub theme which produc ...