浅析 go context
1. Context的用法、有无父子关系？怎么去做并发控制？底层实现！
2. 为什么需要 Context?
用法demo
- WithCancel
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
func gen(ctx context.Context) <-chan int {
dst := make(chan int)
n := 1
go func() {
for {
select {
case <-ctx.Done():
return // return结束该goroutine，防止泄露
case dst <- n:
n++
}
}
}()
return dst
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel() // 当我们取完需要的整数后调用cancel
for n := range gen(ctx) {
fmt.Println(n)
if n == 5 {
break
}
}
}
- WithDeadline：
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)
func main() {
d := time.Now().Add(50 * time.Millisecond)
ctx, cancel := context.WithDeadline(context.Background(), d)
// 尽管ctx会过期，但在任何情况下调用它的cancel函数都是很好的实践。
// 如果不这样做，可能会使上下文及其父类存活的时间超过必要的时间。
defer cancel()
select {
case <-time.After(1 * time.Second):
fmt.Println("overslept")
case <-ctx.Done():
fmt.Println("done:",ctx.Err())
}
}
- WithTimeout
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
func main(){
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
defer cancel() // 通知子goroutine结束
go worker(ctx)
}
- WithValue
func WithValue(parent Context, key, val interface{}) Context
//所提供的键必须是可比较的，并且不应该是内置类型
type TraceCode string
func worker(ctx context.Context) {
key := TraceCode("TRACE_CODE")
val :=ctx.Value(key).(string)
fmt.Println(val)
}
func main() {
ctx := context.WithValue(context.Background(), TraceCode("TRACE_CODE"), "12512312234")
go worker(ctx)
time.Sleep(time.Second * 5)
}
Context类型：
- emptyCtx(用于默认Context):
目前有两个实例化的ctx: background和TODO，background作为整个运行时的默认ctx，而TODO主要用来临时填充未确定具体Context类型的ctx参数 - cancelCtx(带cancel的Context):
最核心的，是WithCancel的底层实现，且可包含多个cancelCtx子节点，从而构成一棵树。 - timerCtx(计时并带cancel的Context)、
- valueCtx(携带kv键值对)，
多种类型可以以父子节点形式相互组合其功能形成新的Context。
cancelCtx的cancel有几种方式
- 主动调用cancel
- 其父ctx被cancel，触发子ctx的cancel
- time.Timer事件触发timerCtx的cancel回调
当一个ctx被cancel后，ctx内部的负责通知的channel被关闭，从而触发select此channel的goroutine获得通知，完成相应逻辑的处理
几种主要Context的实现
type Context interface {
// 只用于timerCtx，即WithDeadline和WithTimeout
Deadline() (deadline time.Time, ok bool)
// 需要获取通知的goroutine可以select此chan，当此ctx被cancel时，会close此chan
Done() <-chan struct{}
// 错误信息
Err() error
// 只用于valueCtx
Value(key interface{}) interface{}
}
// cancelCtx
type cancelCtx struct {
Context
mu sync.Mutex
done chan struct{}
// 主要用于存储子cancelCtx和timerCtx
// 当此ctx被cancel时，会自动cancel其所有children中的ctx
children map[canceler]struct{}
err error
}
// timeCtx
type timerCtx struct {
cancelCtx
// 借助计时器触发timeout事件
timer *time.Timer
deadline time.Time
}
// valueCtx
type valueCtx struct {
Context
key, val interface{}
}
// cancel逻辑
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
/* ... */
c.err = err
// 如果在第一次调用Done之前就调用cancel，则done为nil
if c.done == nil {
c.done = closedchan
} else {
close(c.done)
}
for child := range c.children {
// NOTE: acquiring the child's lock while holding parent's lock.
// 不能将子ctx从当前移除，由于移除需要拿当前ctx的锁
child.cancel(false, err)
}
// 直接置为nil让gc处理子ctx的回收?
c.children = nil
c.mu.Unlock()
// 把自己从parent里移除，注意这里需要拿parent的锁
if removeFromParent {
removeChild(c.Context, c)
}
}
外部接口
// Background
func Background() Context {
// 直接返回默认的顶层ctx
return background
}
// WithCancel
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
// 实例化cancelCtx
c := newCancelCtx(parent)
// 如果parent是cancelCtx类型，则注册到parent.children，否则启用
// 新的goroutine专门负责此ctx的cancel，当parent被cancel后，自动
// 回调child的cancel
propagateCancel(parent, &c)
return &c, func() { c.cancel(true, Canceled) }
}
// WithDeadline
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
// 如果parent是deadline，且比当前早，则直接返回cancelCtx
if cur, ok := parent.Deadline(); ok && cur.Before(deadline) {
return WithCancel(parent)
}
c := &timerCtx{
cancelCtx: newCancelCtx(parent),
deadline: deadline,
}
propagateCancel(parent, c)
d := time.Until(deadline)
// 已经过了
if d <= 0 {
c.cancel(true, DeadlineExceeded) // deadline has already passed
return c, func() { c.cancel(true, Canceled) }
}
c.mu.Lock()
defer c.mu.Unlock()
if c.err == nil {
// time.Timer到时则自动回调cancel
c.timer = time.AfterFunc(d, func() {
c.cancel(true, DeadlineExceeded)
})
}
return c, func() { c.cancel(true, Canceled) }
}
// WithTimeout
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
// 直接使用WithDeadline的实现即可
return WithDeadline(parent, time.Now().Add(timeout))
}
Go标准库Context使用demo:
https://www.liwenzhou.com/posts/Go/go_context/
怎么并发控制
控制并发主要包括两种方式：一种是WaitGroup，另外一种是Context。
WaitGroup是一种控制多个goroutine并发执行的方式
var wg sync.WaitGroup
func service1() {
time.Sleep(2*time.Second)
fmt.Println("service1 done")
wg.Done()
}
func service2() {
time.Sleep(2*time.Second)
fmt.Println("service2 done")
wg.Done()
}
func main() {
wg.Add(2)
go service1()
go service2()
wg.Wait()
fmt.Println("all done")
}
上面的例子是协程内自己处理结束后调用wg.Done退出，实际使用中我们可能需要从外部去结束一个协程。不然它会一直跑，就泄漏了。
如何从外部去结束一个goroutine，很容易想到的一个方法就是定义一个全局变量，然后再外部修改这个变量的值，goroutine不断的轮训这个变量是否改变。
这种方式也可以，但是首先我们要保证这个变量在多线程下的安全，基于此，有一种更好的方式：channel + select
func testChannel() {
stop := make(chan bool)
go func() {
for {
select {
case <-stop:
fmt.Println("goroutine done")
return
default:
fmt.Println("goroutine is running")
time.Sleep(2 * time.Second)
}
}
}()
time.Sleep(10 * time.Second)
fmt.Println("cancel goroutine")
stop<- true
//为了检测监控过是否停止，如果没有监控输出，就表示停止了
time.Sleep(5 * time.Second)
}
这种方式也有局限性，如果有很多goroutine都需要控制结束怎么办呢？如果这些goroutine又衍生了其他更多的goroutine怎么办呢？如果一层层的无穷尽的goroutine呢？这就非常复杂了，即使我们定义很多chan也很难解决这个问题，因为goroutine的关系链就导致了这种场景非常复杂。
context可以很好的解决上面的问题。下面用context的方式改写上面的例子。
func testContext() {
ctx, cancel := context.WithCancel(context.Background())
go func(ctx context.Context) {
for {
select {
case <-ctx.Done():
fmt.Println("goroutine done")
return
default:
fmt.Println("goroutine is running")
time.Sleep(2 * time.Second)
}
}
}(ctx)
time.Sleep(10 * time.Second)
fmt.Println("cancel goroutine")
cancel()
//为了检测监控过是否停止，如果没有监控输出，就表示停止了
time.Sleep(5 * time.Second)
}
context.Background() 返回一个空的Context，这个空的Context一般用于整个Context树的根节点。然后我们使用context.WithCancel(parent)函数，创建一个可取消的子Context，然后当作参数传给goroutine使用，这样就可以使用这个子Context跟踪这个goroutine。
在goroutine中，使用select调用<-ctx.Done()判断是否要结束，如果接受到值的话，就可以返回结束goroutine了；如果接收不到，就会继续进行监控。
那么是如何发送结束指令的呢？这就是示例中的cancel函数啦，它是我们调用context.WithCancel(parent)函数生成子Context的时候返回的，第二个返回值就是这个取消函数，它是CancelFunc类型的。我们调用它就可以发出取消指令，然后我们的监控goroutine就会收到信号，就会返回结束。
Context控制多个goroutine
func testMultiContext() {
ctx, cancel := context.WithCancel(context.Background())
go watch(ctx, "watch1")
go watch(ctx, "watch2")
time.Sleep(10 * time.Second)
fmt.Println("cancel all goroutine")
cancel()
//为了检测监控过是否停止，如果没有监控输出，就表示停止了
time.Sleep(5 * time.Second)
}
func watch(ctx context.Context, name string) {
for {
select {
case <-ctx.Done():
fmt.Println(name," is done")
return
default:
fmt.Println(name," is running")
time.Sleep(2 * time.Second)
}
}
}
Context 使用原则
- 不要把Context放在结构体中，要以参数的方式传递
- 以Context作为参数的函数方法，应该把Context作为第一个参数，放在第一位。
- 给一个函数方法传递Context的时候，不要传递nil，如果不知道传递什么，就使用context.TODO
- Context的Value相关方法应该传递必须的数据，不要什么数据都使用这个传递
- Context是线程安全的，可以放心的在多个goroutine中传递