「Go语言面试题」21 -为什么你的Go服务需要Context？一文掌握超时控制与取消传播

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}

// 创建根Context
rootCtx := context.Background()

// 派生带超时的子Context
timeoutCtx, cancel := context.WithTimeout(rootCtx, 5*time.Second)
defer cancel()

// 继续派生带值的孙Context
valueCtx := context.WithValue(timeoutCtx, "requestID", "12345")

[调用方] → [WithTimeout创建定时Context] → [启动goroutine执行任务]
    ↓                               ↓
[定时器到期] → [关闭Done channel] → [所有监听该Context的goroutine收到信号]

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
    return WithDeadline(parent, time.Now().Add(timeout))
}

// 示例：超时控制实战
func apiCall(ctx context.Context) error {
    // 模拟耗时操作
    select {
    case <-time.After(3 * time.Second):
        return nil // 正常完成
    case <-ctx.Done():
        return ctx.Err() // 超时或被取消
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
    
    if err := apiCall(ctx); err != nil {
        fmt.Println("调用失败:", err) // 会输出"调用失败: context deadline exceeded"
    }
}

[根Context取消] → [子Context1收到信号] → [孙Context1-1收到信号]
              → [子Context2收到信号] → [孙Context2-1收到信号]
                                  → [孙Context2-2收到信号]

// 级联取消演示
func main() {
    parentCtx, cancelParent := context.WithCancel(context.Background())
    
    // 启动多个worker
    go worker(parentCtx, "worker1")
    go worker(parentCtx, "worker2")
    
    // 3秒后取消父Context
    time.Sleep(3 * time.Second)
    cancelParent() // 所有worker都会收到取消信号
    
    time.Sleep(1 * time.Second) // 给worker一些时间处理
}

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("%s: 收到取消信号，开始清理工作", name)
            time.Sleep(500 * time.Millisecond) // 模拟清理操作
            fmt.Printf("%s: 清理完成，退出", name)
            return
        case <-time.After(1 * time.Second):
            fmt.Printf("%s: 正在工作...", name)
        }
    }
}

// 定义上下文键类型，避免键名冲突
type contextKey string

const (
    requestIDKey contextKey = "requestID"
    userAuthKey  contextKey = "userAuth"
)

// 设置值
func setRequestID(ctx context.Context, id string) context.Context {
    return context.WithValue(ctx, requestIDKey, id)
}

// 获取值
func getRequestID(ctx context.Context) (string, bool) {
    id, ok := ctx.Value(requestIDKey).(string)
    return id, ok
}

// 使用示例
func handleRequest(ctx context.Context) {
    if requestID, ok := getRequestID(ctx); ok {
        fmt.Printf("处理请求 %s
", requestID)
    }
}

[ContextA] → [值: {key1: value1}] 
          → [ContextB] → [值: {key2: value2}]
          → [ContextC] → [值: {key3: value3}]

// 类型安全的封装
func WithUserID(ctx context.Context, userID int64) context.Context {
    return context.WithValue(ctx, userIDKey, userID)
}

func GetUserID(ctx context.Context) (int64, error) {
    value := ctx.Value(userIDKey)
    if value == nil {
        return 0, errors.New("user ID not found in context")
    }
    
    userID, ok := value.(int64)
    if !ok {
        return 0, errors.New("invalid user ID type in context")
    }
    
    return userID, nil
}

// 错误示例：忘记调用cancel可能导致内存泄露
func leakyFunction() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    // 忘记 defer cancel()
    
    go func() {
        <-ctx.Done()
        // 这个goroutine可能永远不会退出
    }()
}

// 正确做法
func correctFunction() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel() // 确保cancel被调用
    
    go func() {
        <-ctx.Done()
        // 正常退出
    }()
}

// 不推荐
type Service struct {
    ctx context.Context
}

// 推荐：在方法中传递Context
func (s *Service) Process(ctx context.Context) error {
    // 使用传入的Context
}