「Go语言模拟面试」05- 解释Go中的context包，以及它在并发编程中的作用？

func worker(ctx context.Context) {
    select {
    case <-ctx.Done(): // 监听取消信号
        fmt.Println("取消原因:", ctx.Err())
    case <-time.After(time.Second):
        fmt.Println("工作完成")
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go worker(ctx)
    
    time.Sleep(500 * time.Millisecond)
    cancel() // 发出取消信号
    time.Sleep(time.Second)
}
// 输出：取消原因: context canceled

func apiCall(ctx context.Context) error {
    select {
    case <-time.After(2 * time.Second):
        return nil // 模拟成功
    case <-ctx.Done():
        return ctx.Err() // 返回超时错误
    }
}

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

func process(ctx context.Context) {
    if deadline, ok := ctx.Deadline(); ok {
        fmt.Println("截止时间:", deadline)
    }
}

func main() {
    ctx, cancel := context.WithDeadline(
        context.Background(),
        time.Now().Add(3*time.Second)
    )
    defer cancel()
    process(ctx)
}

type key string

func middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := context.WithValue(r.Context(), key("userID"), "12345")
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func handler(w http.ResponseWriter, r *http.Request) {
    userID := r.Context().Value(key("userID")).(string)
    fmt.Fprintf(w, "用户ID: %s", userID)
}

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

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    
    // 设置数据库查询超时
    dbCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()
    
    result, err := db.QueryContext(dbCtx, "SELECT...")
    if err != nil {
        if errors.Is(err, context.DeadlineExceeded) {
            http.Error(w, "数据库查询超时", http.StatusGatewayTimeout)
            return
        }
    }
    // ...
}

func processOrder(ctx context.Context, orderID string) error {
    // 创建子Context（总超时5秒）
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()
    
    // 并发调用多个服务
    g, ctx := errgroup.WithContext(ctx)
    g.Go(func() error { return inventoryService.Reserve(ctx, orderID) })
    g.Go(func() error { return paymentService.Charge(ctx, orderID) })
    g.Go(func() error { return shippingService.Schedule(ctx, orderID) })
    
    return g.Wait() // 任一失败则取消所有
}

func longTask(ctx context.Context) error {
    for i := 0; i < 100; i++ {
        select {
        case <-ctx.Done():
            return ctx.Err() // 被取消时立即退出
        default:
            // 执行任务片段
            if err := doWork(i); err != nil {
                return err
            }
            
            // 定期检查取消信号
            if i%10 == 0 {
                if ctx.Err() != nil {
                    return ctx.Err()
                }
            }
        }
    }
    return nil
}

ctx, cancel := context.WithCancel(context.Background())
defer cancel() // 确保资源释放

// 错误：未考虑父Context超时
func callService(parentCtx context.Context) {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
    // 应使用：context.WithTimeout(parentCtx, ...)
}

// 不推荐：多层嵌套增加开销
ctx := context.WithValue(
    context.WithTimeout(
        context.WithValue(parentCtx, key1, val1),
        2*time.Second),
    key2, val2)

// 推荐：单层构造
ctx, cancel := context.WithTimeout(parentCtx, 2*time.Second)
ctx = context.WithValue(ctx, key1, val1)
ctx = context.WithValue(ctx, key2, val2)

// 在循环外获取值
userID := ctx.Value(userKey).(string)
for i := 0; i < 10000; i++ {
    // 使用userID而不是重复查找
}

type fastCtx struct {
    context.Context
    userID string
}

func (f *fastCtx) Value(key interface{}) interface{} {
    if key == (userKey{}) {
        return f.userID
    }
    return f.Context.Value(key)
}