golang中Context的使用场景

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    resultChan := make(chan string)

    go func() {
        // 模拟耗时操作
        time.Sleep(2 * time.Second)
        resultChan <- "result"
    }()

    select {
    case <-ctx.Done():
        // 请求取消或超时
        http.Error(w, "request canceled", http.StatusRequestTimeout)
    case result := <-resultChan:
        // 正常返回结果
        fmt.Fprintln(w, result)
    }
}

func fetchData(ctx context.Context) (string, error) {
    ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()

    ch := make(chan string, 1)
    go func() {
        // 模拟耗时操作
        time.Sleep(3 * time.Second)
        ch <- "data"
    }()

    select {
    case <-ctx.Done():
        return "", ctx.Err() // 返回超时或取消错误
    case result := <-ch:
        return result, nil
    }
}

func main() {
    ctx := context.Background()
    ctx = context.WithValue(ctx, "requestID", "12345")

    processRequest(ctx)
}

func processRequest(ctx context.Context) {
    reqID := ctx.Value("requestID")
    fmt.Println("Request ID:", reqID)
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    go worker(ctx, "worker1")
    go worker(ctx, "worker2")

    time.Sleep(1 * time.Second)
    cancel() // 取消所有工作

    time.Sleep(1 * time.Second)
}

func worker(ctx context.Context, name string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println(name, "stopped")
            return
        default:
            fmt.Println(name, "working")
            time.Sleep(500 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    sem := make(chan struct{}, 3) // 限制并发数为3
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            sem <- struct{}{} // 获取信号
            defer func() { <-sem }() // 释放信号

            worker(ctx, i)
        }(i)
    }

    wg.Wait()
}

func worker(ctx context.Context, id int) {
    select {
    case <-ctx.Done():
        fmt.Printf("worker %d canceled\n", id)
        return
    default:
        fmt.Printf("worker %d working\n", id)
        time.Sleep(1 * time.Second)
    }
}