咱们先以一个例子开头
package main
import (
"context"
"fmt"
"sync"
)
var wg sync.WaitGroup
func main() {
wg.Add(2)
ctx, cancel := context.WithCancel(context.Background())
go dosth(ctx, 1, &wg)
go dosth(ctx, 2, &wg)
cancel() //调用取消方法 实质是将一个close的通道赋值给ctx的done通道属性 ,这样监听done通道的协程都可以收到消息
wg.Wait()
}
func dosth(ctx context.Context, i int, w *sync.WaitGroup) {
for {
select {
case x := <-ctx.Done(): //监听done通道的通知(内部其实就是一个close的通道(所有协程都能收到消息) 见下面内容)
fmt.Println("canced ", i, x)
w.Done()
return
default:
fmt.Println("default", i)
w.Done()
return
}
}
}
上面的代码执行结果:
canced 2 {}
canced 1 {}
如果不知道为什么,请继续阅读下面内容:
为什么需要context
在并发程序中,由于超时、取消操作或者一些异常情况,往往需要进行抢占操作或者中断后续操作。熟悉channel
的朋友应该都见过使用done channel
来处理此类问题。比如以下这个例子:
func main() {
messages := make(chan int, 10)
done := make(chan bool)
defer close(messages)
// consumer
go func() {
ticker := time.NewTicker(1 * time.Second)
for _ = range ticker.C {
select {
case <-done:
fmt.Println("child process interrupt...")
return
default:
fmt.Printf("send message: %d\n", <-messages)
}
}
}()
// producer
for i := 0; i < 10; i++ {
messages <- i
}
time.Sleep(5 * time.Second)
close(done)
time.Sleep(1 * time.Second)
fmt.Println("main process exit!")
}
上述例子中定义了一个buffer
为0的channel done
, 子协程运行着定时任务。如果主协程需要在某个时刻发送消息通知子协程中断任务退出,那么就可以让子协程监听这个done channel
,一旦主协程关闭done channel
,那么子协程就可以推出了,这样就实现了主协程通知子协程的需求。这很好,但是这也是有限的。
如果我们可以在简单的通知上附加传递额外的信息来控制取消:为什么取消,或者有一个它必须要完成的最终期限,更或者有多个取消选项,我们需要根据额外的信息来判断选择执行哪个取消选项。
考虑下面这种情况:假如主协程中有多个任务1, 2, …m,主协程对这些任务有超时控制;而其中任务1又有多个子任务1, 2, …n,任务1对这些子任务也有自己的超时控制,那么这些子任务既要感知主协程的取消信号,也需要感知任务1的取消信号。
如果还是使用done channel
的用法,我们需要定义两个done channel
,子任务们需要同时监听这两个done channel
。嗯,这样其实好像也还行哈。但是如果层级更深,如果这些子任务还有子任务,那么使用done channel
的方式将会变得非常繁琐且混乱。
我们需要一种优雅的方案来实现这样一种机制:
- 上层任务取消后,所有的下层任务都会被取消;
- 中间某一层的任务取消后,只会将当前任务的下层任务取消,而不会影响上层的任务以及同级任务。
开头引入的那个例子中WithCancel是golang context常见的使用,下面我们追下WithCancel的源代码
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
c := newCancelCtx(parent)
propagateCancel(parent, &c)
return &c, func() { c.cancel(true, Canceled) }
}
//new一个cancel实例
func newCancelCtx(parent Context) cancelCtx {
return cancelCtx{Context: parent}
}
type cancelCtx struct {
Context
mu sync.Mutex // protects following fields
done chan struct{} // created lazily, closed by first cancel call
children map[canceler]struct{} // set to nil by the first cancel call
err error // set to non-nil by the first cancel call
}
func (c *cancelCtx) Done() <-chan struct{} {
c.mu.Lock()
if c.done == nil {
c.done = make(chan struct{})
}
d := c.done
c.mu.Unlock()
return d
}
func (c *cancelCtx) Err() error {
c.mu.Lock()
err := c.err
c.mu.Unlock()
return err
}
func (c *cancelCtx) String() string {
return fmt.Sprintf("%v.WithCancel", c.Context)
}
// cancel方法是cancelCtx的核心
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 // already canceled
}
c.err = err
if c.done == nil {
c.done = closedchan //将一个close的通道赋值给cancelCtx的done通道变量(见init方法),这样监听这个变量的所有协程都会收到信息,收到信息后就可以进行各自的逻辑处理 达到通信的效果
} else {
close(c.done)
}
for child := range c.children {
// NOTE: acquiring the child's lock while holding parent's lock.
child.cancel(false, err)
}
c.children = nil
c.mu.Unlock()
if removeFromParent {
removeChild(c.Context, c)
}
}
// closedchan is a reusable closed channel.
var closedchan = make(chan struct{})
//包引入的时候就把通道关闭 供上面说的地方使用
func init() {
close(closedchan)
}
WithTimeout context与WithCancel类似,只是多了一个定时cancel的功能,也就是不用在使用的代码里手动调用cancel方法 到时间后程序自动调用cancel ,核心源码见下面的:time.AfterFunc
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
if cur, ok := parent.Deadline(); ok && cur.Before(d) {
// The current deadline is already sooner than the new one.
return WithCancel(parent)
}
c := &timerCtx{
cancelCtx: newCancelCtx(parent),
deadline: d,
}
propagateCancel(parent, c)
dur := time.Until(d)
if dur <= 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 {
c.timer = time.AfterFunc(dur, func() {
c.cancel(true, DeadlineExceeded)
})
}
return c, func() { c.cancel(true, Canceled) }
}
思路点到为止,细节之处必须自己去看源码方能更清楚