context — 上下文传递与取消

// 根 context（通常在整个程序入口使用）
ctx := context.Background()    // 用于 main、init、测试
ctx := context.TODO()          // 占位符：表示"还没想好用哪种 " 

// 派生的 context
ctx, cancel := context.WithCancel(parent)           // 手动取消
ctx, cancel := context.WithTimeout(parent, 5*time.Second)  // 绝对超时
ctx, cancel := context.WithDeadline(parent, deadline)       // 截止时间
ctx := context.WithValue(parent, key, value)                // 携带值

// 带原因的取消（Go 1.20）
ctx, cancel := context.WithCancelCause(parent)
cancel(errors.New("upstream 503"))   // CancelCauseFunc(error)
ctx.Err()          // 永远返回 context.Canceled（类型判断不受影响）
context.Cause(ctx) // 拿到真正的取消原因

// 超时也能带原因（Go 1.21）
ctx, cancel := context.WithTimeoutCause(ctx, 3*time.Second,
    errors.New("client budget exceeded"))

// 取消后执行清理回调（Go 1.21）
stop := context.AfterFunc(ctx, func() { conn.Close() })
defer stop() // 返回 true = 成功阻止了 f 的运行

// 剥离取消信号，保留值（Go 1.21）：用于"请求已结束，但后台任务要继续写日志/审计"
bg := context.WithoutCancel(reqCtx)
go func() { audit.Write(bg, rec) }()

parentCtx, cancel := context.WithCancel(context.Background())
defer cancel()

childCtx, _ := context.WithCancel(parentCtx)

// 取消 parent → child 也被取消
// 取消 child → parent 不受影响
cancel() // parent 和 child 都收到 Done() signal

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():  // ← 返回一个只读 channel
            fmt.Println("cancelled:", ctx.Err())
            return
        default:
            doWork()
        }
    }
}

// 正确 — 把 ctx.Done() 放进 select
select {
case <-ctx.Done():
    return ctx.Err()
case result := <-workCh:
    return process(result)
}

// 错误 — 只等 time.After，不接上层的取消信号
select {
case <-time.After(timeout):
    return ErrTimeout
case result := <-workCh:
    return process(result)
}
// 问题：调用方 cancel 了 ctx，这个 goroutine 仍会傻等到超时才退出。
// 三个分支一起 select 才是完整写法（Done / workCh / 自己的超时）。

// 1. 定义私有 key 类型（避免冲突）
type contextKey string  // 或用 struct{} 更安全

const (
    requestIDKey contextKey = "requestID"
    userIDKey    contextKey = "userID"
)

// 2. 封装存取函数
func WithRequestID(ctx context.Context, id string) context.Context {
    return context.WithValue(ctx, requestIDKey, id)
}

func RequestID(ctx context.Context) string {
    id, _ := ctx.Value(requestIDKey).(string)
    return id
}

// WithValue 在父 ctx 基础上添加键值对（不可变设计）
ctx := context.Background()
ctx = context.WithValue(ctx, key1, "val1")
ctx = context.WithValue(ctx, key2, "val2")

// 查找链：ctx → key2（不匹配）→ 父 ctx → key1（匹配）
// 时间复杂度：O(depth)，不建议嵌套太深

func fetchURL(ctx context.Context, url string) ([]byte, error) {
    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}

// 调用方设置总体超时
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
data, err := fetchURL(ctx, "https://example.com")

func queryUsers(ctx context.Context, db *sql.DB, name string) ([]User, error) {
    // 为单个查询再设置更短的超时
    queryCtx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
    defer cancel()
    return db.QueryContext(queryCtx, "SELECT * FROM users WHERE name = ?", name)
}

// 串行：每个操作独立超时
func serialWork(ctx context.Context) error {
    // 操作 A: 最多 1s
    ctxA, cancelA := context.WithTimeout(ctx, time.Second)
    defer cancelA()
    if err := doA(ctxA); err != nil {
        return err
    }

    // 操作 B: 最多 2s
    ctxB, cancelB := context.WithTimeout(ctx, 2*time.Second)
    defer cancelB()
    return doB(ctxB)
}

// 并行：同时启动，等任意完成或全部超时
func parallelWork(ctx context.Context) error {
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()

    ch := make(chan error, 2)
    go func() { ch <- doA(ctx) }()
    go func() { ch <- doB(ctx) }()

    for i := 0; i < 2; i++ {
        if err := <-ch; err != nil {
            return err // ← 隐式触发 cancel()，另一个 goroutine 被取消
        }
    }
    return nil
}

// 给 Context 套一个"缺省超时"：父 ctx 没有 deadline 时补一个
type timeoutContext struct {
    context.Context // 内联：未显式实现的方法全部转发给父 ctx
}

func (c *timeoutContext) Deadline() (time.Time, bool) {
    if d, ok := c.Context.Deadline(); ok {
        return d, true
    }
    return time.Now().Add(30 * time.Second), true
}

func WithDefaultTimeout(parent context.Context) context.Context {
    return &timeoutContext{parent}
}