Golang context包：控制协程、超时与链路追踪实战

package main

import (
	"context"
	"errors"
	"fmt"
	"sync"
)

// request模拟一个可能需要取消的网络请求
func request(ctx context.Context, url string) error {
	result := make(chan int)
	errChan := make(chan error)

	go func() {
		// 模拟业务逻辑执行
		isSuccess := true 
		if isSuccess {
			result <- 1
		} else {
			errChan <- errors.New("业务处理错误")
		}
	}()

	// select监听退出信号或任务结果
	select {
	case <-ctx.Done():
		return ctx.Err() // 收到取消信号，返回错误
	case e := <-errChan:
		return e
	case <-result:
		return nil
	}
}

func main() {
	// 1. 创建带取消功能的上下文
	ctx, cancel := context.WithCancel(context.Background())

	var wg sync.WaitGroup

	// 2. 启动子协程A
	wg.Add(1)
	go func() {
		defer wg.Done()
		if err := request(ctx, "https://example.com/a"); err != nil {
			fmt.Println("Request A Error:", err)
			// 如果A失败，触发取消，通知其他正在等待的请求
			cancel()
		}
	}()

	// 3. 启动子协程B
	wg.Add(1)
	go func() {
		defer wg.Done()
		if err := request(ctx, "https://example.com/b"); err != nil {
			fmt.Println("Request B Error:", err)
			cancel()
		}
	}()

	// 4. 等待所有协程完成退出逻辑
	wg.Wait()
}

package main

import (
	"context"
	"io"
	"log"
	"net/http"
	"time"
)

func main() {
	// 构造一个超时间为50毫秒的Context
	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
	defer cancel() // 确保资源释放

	// 创建HTTP请求并绑定Context
	req, _ := http.NewRequest(http.MethodGet, "https://www.example.com", nil)
	req = req.WithContext(ctx)

	// 执行请求
	client := &http.Client{}
	res, err := client.Do(req)
	
	// 处理可能的超时错误
	if err != nil {
		// 如果因为超时而报错，通常会打印 context deadline exceeded
		log.Printf("Request failed: %v\n", err)
		return
	}
	defer res.Body.Close()

	body, _ := io.ReadAll(res.Body)
	log.Println(string(body))
}

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
)

// 定义安全的Key类型
const traceIdKey = "trace_id"

// ServeHTTP模拟接收HTTP请求的入口
func handleRequest(w http.ResponseWriter, req *http.Request) {
	// 1. 获取或生成TraceID
	traceID := req.Header.Get("X-Trace-ID")
	if traceID == "" {
		traceID = "generated-12345"
	}

	// 2. 将traceID存入新的Context中
	ctx := context.WithValue(req.Context(), traceIdKey, traceID)

	// 3. (可选)同时附加超时逻辑
	ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
	defer cancel()

	// 4. 向下传递Context进行后续操作
	processBusinessLogic(ctx)
}

func processBusinessLogic(ctx context.Context) {
	// 在下层函数中提取刚才存入的值
	idVal := ctx.Value(traceIdKey)
	
	// 发起RPC或DB查询时，依然传入这个ctx
	// ... RPCClient.Call(ctx, ...) ...
	
	fmt.Printf("Processing request with TraceID: %v\n", idVal)
}