// 源碼簡化版
type cancelCtx struct {
    Context             // 1. 嵌入父 Context，保證能調(diào)用父類方法
    mu       sync.Mutex // 2. 互斥鎖，保證并發(fā)安全（保護下面的字段）
    done     chan struct{} // 3. 核心！用來發(fā)信號的 Channel
    children map[canceler]struct{} // 4. 存自己的“孩子”，以便取消時通知它們
    err      error      // 5. 記錄取消原因（Canceled 還是 DeadlineExceeded）
}

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
    c := newCancelCtx(parent) // 創(chuàng)建自己
    propagateCancel(parent, &c) // 【關(guān)鍵】把自己掛到父節(jié)點上
    return &c, func() { c.cancel(true, Canceled) }
}

	done := parent.Done()
	if done == nil {
		return // parent is never canceled
	}

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

	if p, ok := parentCancelCtx(parent); ok {
		// parent is a *cancelCtx, or derives from one.
		p.mu.Lock()
		if err := p.err.Load(); err != nil {
			// parent has already been canceled
			child.cancel(false, err.(error), p.cause)
		} else {
			if p.children == nil {
				p.children = make(map[canceler]struct{})
			}
			p.children[child] = struct{}{}
		}
		p.mu.Unlock()
		return
	}

	if a, ok := parent.(afterFuncer); ok {
		// parent implements an AfterFunc method.
		c.mu.Lock()
		stop := a.AfterFunc(func() {
			child.cancel(false, parent.Err(), Cause(parent))
		})
		c.Context = stopCtx{
			Context: parent,
			stop:    stop,
		}
		c.mu.Unlock()
		return
	}

	if a, ok := parent.(afterFuncer); ok {
		// parent implements an AfterFunc method.
		c.mu.Lock()
		stop := a.AfterFunc(func() {
			child.cancel(false, parent.Err(), Cause(parent))
		})
		c.Context = stopCtx{
			Context: parent,
			stop:    stop,
		}
		c.mu.Unlock()
		return
	}

	goroutines.Add(1)
	go func() {
		select {
		case <-parent.Done():
			child.cancel(false, parent.Err(), Cause(parent))
		case <-child.Done():
		}
	}()

// removeFromParent: 是否需要把自己從父親的 map 中移除
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
    c.mu.Lock()
    if c.err != nil { // 如果已經(jīng)取消過了，直接返回
        c.mu.Unlock()
        return
    }
    c.err = err // 記錄錯誤原因

    // 1. 【核心動作】關(guān)閉 channel！
    // 此時，所有監(jiān)聽 <-ctx.Done() 的協(xié)程都會瞬間收到信號
    if c.done == nil {
        c.done = closedchan
    } else {
        close(c.done)
    }

    // 2. 【遞歸通知】遍歷所有孩子，挨個調(diào)用它們的 cancel
    for child := range c.children {
        // 遞歸調(diào)用孩子的 cancel 方法
        // 注意：這里傳 false，意思是孩子不需要從我這里移除（因為我自己都要沒了，大家一起銷毀）
        child.cancel(false, err) 
    }
    c.children = nil // 釋放 map，利用 GC 回收內(nèi)存
    c.mu.Unlock()

    // 3. 【斷絕關(guān)系】把自己從父親的 map 里刪掉
    // 避免父親一直持有我的引用，導(dǎo)致內(nèi)存泄漏
    if removeFromParent {
        removeChild(c.Context, c)
    }
}

// src/context/context.go

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
	c := newCancelCtx(parent)
	propagateCancel(parent, &c) // 把自己掛到父親節(jié)點
	
	// 【注意看這里】
	// 返回的閉包函數(shù)，硬編碼了 true
	return &c, func() { c.cancel(true, Canceled) }
}

// src/context/context.go -> cancel 方法內(nèi)部

// ... 前面是關(guān)閉 channel 的邏輯

// 遍歷所有的孩子
for child := range c.children {
    // 【注意看這里】
    // 父親取消孩子時，傳的是 false
    child.cancel(false, err) 
}
c.children = nil // 父親直接清空整個 map
c.mu.Unlock()

// 如果 removeFromParent 為 true，才去調(diào)用 removeChild
if removeFromParent {
    removeChild(c.Context, c)
}