Go Context解析 A Brief Inquiry Into Go Context

// withoutCancel 不取消协程
func withoutCancel() {
	go func() {
		go func() {
			defer fmt.Println("child dead")
			for {
				fmt.Println("child running...")
				time.Sleep(1 * time.Second)
			}
		}()
		for i := 0; i < 2; i++ {
			fmt.Println("father running...")
			time.Sleep(1 * time.Second)
		}
		defer fmt.Println("father dead")
	}()
	time.Sleep(5 * time.Second)
}
output:
father running...
child running...
child running...
father running...
father dead
child running...
child running...
child running...
child running...

// withChannel 使用通道取消协程
func withChannel() {
	go func() {
		c := make(chan bool)
		defer fmt.Println("father dead")
		go func() {
			defer fmt.Println("child dead")
			for {
				select {
				case <-c:
					return
				default:
					fmt.Println("child running...")
					time.Sleep(1 * time.Second)
				}
			}
		}()
		for i := 0; i < 2; i++ {
			time.Sleep(1 * time.Second)
			fmt.Println("father running...")
		}
		c <- true
	}()
	time.Sleep(5 * time.Second)
}
output:
child running...
father running...
child running...
child running...
father running...
child dead
father dead

type Context interface {
    Deadline() (deadline time.Time, ok bool) // 返回context被取消的时间
    Done() <-chan struct{} // 返回一个channel,这个channel会在当前工作完成或者上下文被取消后关闭
    Err() error // 返回context结束的原因
    Value(key interface{}) interface{}
}

type emptyCtx int

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

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

func (c *valueCtx) Value(key interface{}) interface{} {
	if c.key == key {
		return c.val
	}
	return c.Context.Value(key)
}

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 WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
	if parent == nil {
		panic("cannot create context from nil parent")
	}
	c := newCancelCtx(parent)
	propagateCancel(parent, &c)
	return &c, func() { c.cancel(true, Canceled) }
}
func newCancelCtx(parent Context) cancelCtx {
	return cancelCtx{Context: parent}
}

func propagateCancel(parent Context, child canceler) {
	done := parent.Done()
	if done == nil {
		return // parent is never canceled
	}

	select {
	case <-done:
		// parent is already canceled
		child.cancel(false, parent.Err())
		return
	default:
	}

	p, ok := parentCancelCtx(parent) ok {
		p.mu.Lock()
		if p.err != nil {
			// parent has already been canceled
			child.cancel(false, p.err)
		} else {
			if p.children == nil {
				p.children = make(map[canceler]struct{})
			}
			p.children[child] = struct{}{}
		}
		p.mu.Unlock()
	} else {
		atomic.AddInt32(&goroutines, +1)
		go func() {
			select {
			case <-parent.Done():
				child.cancel(false, parent.Err())
			case <-child.Done():
			}
		}()
	}
}

type timerCtx struct {
	cancelCtx
	timer *time.Timer // Under cancelCtx.mu.

	deadline time.Time
}

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
	if parent == nil {
		panic("cannot create context from nil parent")
	}
	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(false, 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) }
}