2. Go 语言基础回顾：Goroutine 与 Channel 基础、select 多路复用、context 包的使用

在构建低尾延迟搜索系统时，Go 语言的并发原语是核心武器。本章将系统回顾 Goroutine 与 Channel 的基础用法、select 多路复用机制以及 context 包的生命周期控制能力，为后续实现请求折叠、超时熔断和级联取消奠定基础。

2.1 Goroutine：轻量级并发单元

Goroutine 是 Go 运行时管理的轻量级线程，初始栈仅几 KB，创建和销毁成本极低。在搜索系统中，每个查询分片、每个缓存预热任务都可以由一个 Goroutine 承载。

// 基础 Goroutine 启动与等待
func searchShard(shardID int, query string, wg *sync.WaitGroup) {
    defer wg.Done()
    // 执行分片搜索逻辑
    results := executeShardSearch(shardID, query)
    // 合并结果...
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < numShards; i++ {
        wg.Add(1)
        go searchShard(i, "golang tail latency", &wg)
    }
    wg.Wait()
    // 所有分片搜索完成
}

2.2 Channel：Goroutine 间的安全通信

Channel 是 Go 的 CSP（Communicating Sequential Processes）模型核心，用于在 Goroutine 之间传递数据。在搜索系统中，Channel 常用于收集分片结果、传递取消信号和实现请求队列。

2.2.1 无缓冲与有缓冲 Channel

// 使用有缓冲 Channel 收集分片搜索结果
type shardResult struct {
    shardID int
    hits    []string
    err     error
}

func collectResults(numShards int, results chan shardResult) []string {
    var allHits []string
    for i := 0; i < numShards; i++ {
        r := <-results
        if r.err != nil {
            log.Printf("shard %d error: %v", r.shardID, r.err)
            continue
        }
        allHits = append(allHits, r.hits...)
    }
    return allHits
}

2.2.2 Channel 方向与所有权

在函数签名中明确 Channel 方向可以增强代码安全性：<-chan T 表示只读，chan<- T 表示只写。搜索系统中，生产者函数应返回只写 Channel，消费者函数应接收只读 Channel。

// 生产者：返回只写 Channel
func produceShardResults(query string) <-chan shardResult {
    out := make(chan shardResult, 10)
    go func() {
        defer close(out)
        for i := 0; i < numShards; i++ {
            out <- executeShard(i, query)
        }
    }()
    return out
}

// 消费者：接收只读 Channel
func consumeResults(in <-chan shardResult) []string {
    var hits []string
    for r := range in {
        hits = append(hits, r.hits...)
    }
    return hits
}

2.3 select 多路复用：并发控制的核心

select 语句允许一个 Goroutine 同时等待多个 Channel 操作，是构建超时控制、优雅退出和请求折叠的关键机制。

// 带超时的分片搜索
func searchWithTimeout(shardID int, query string, timeout time.Duration) ([]string, error) {
    resultCh := make(chan []string, 1)
    errCh := make(chan error, 1)

    go func() {
        hits, err := executeShardSearch(shardID, query)
        if err != nil {
            errCh <- err
            return
        }
        resultCh <- hits
    }()

    select {
    case hits := <-resultCh:
        return hits, nil
    case err := <-errCh:
        return nil, err
    case <-time.After(timeout):
        return nil, fmt.Errorf("shard %d timeout after %v", shardID, timeout)
    }
}

2.4 context 包：请求级生命周期管理

context.Context 是 Go 标准库提供的请求上下文传递机制，支持超时控制、取消信号传播和元数据传递。在搜索系统中，每个入站请求都应创建一个根 Context，并沿调用链向下传递。

2.4.1 四种核心 Context 创建方式

// 搜索请求的 Context 传递链
func searchHandler(w http.ResponseWriter, r *http.Request) {
    // 从 HTTP 请求创建带超时的 Context
    ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
    defer cancel()

    // 传递 traceID
    ctx = context.WithValue(ctx, "traceID", generateTraceID())

    results, err := aggregateSearch(ctx, r.URL.Query().Get("q"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusGatewayTimeout)
        return
    }
    json.NewEncoder(w).Encode(results)
}

func aggregateSearch(ctx context.Context, query string) ([]string, error) {
    // 检查 Context 是否已取消
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }

    // 启动分片搜索，传递子 Context
    type shardResult struct {
        hits []string
        err  error
    }
    resultCh := make(chan shardResult, numShards)

    for i := 0; i < numShards; i++ {
        go func(id int) {
            // 每个分片使用独立的子 Context
            shardCtx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
            defer cancel()
            hits, err := searchShard(shardCtx, id, query)
            resultCh <- shardResult{hits, err}
        }(i)
    }

    // 收集结果，优先处理快分片
    var allHits []string
    for i := 0; i < numShards; i++ {
        select {
        case res := <-resultCh:
            if res.err == nil {
                allHits = append(allHits, res.hits...)
            }
        case <-ctx.Done():
            return allHits, ctx.Err() // 返回已收集的部分结果
        }
    }
    return allHits, nil
}

2.4.2 Context 的级联取消机制

当父 Context 被取消时，所有派生的子 Context 都会自动收到取消信号。这一机制在搜索系统中用于实现“快速失败”：一旦某个关键分片超时或出错，立即取消其他仍在运行的分片搜索，释放资源。

2.5 常见并发模式与避坑指南

2.5.1 并发模式对比

2.5.2 常见并发陷阱

• Goroutine 泄漏：Goroutine 在 Channel 上阻塞且没有其他 Goroutine 读取，导致无法退出。解决方案：使用 Context 传递取消信号，确保所有 Goroutine 都能响应退出。
• 对已关闭 Channel 发送数据：导致 panic。解决方案：使用 sync.Once 或专门的关闭标志确保只关闭一次。
• 未检查 Context 取消：在长时间操作中未检查 ctx.Done()，导致资源浪费。解决方案：在循环、数据库查询、网络调用前检查 Context 状态。
• 共享内存未加锁：多个 Goroutine 同时读写 map/slice 导致 data race。解决方案：使用 Channel 传递所有权，或使用 sync.Mutex/RWMutex 保护。

2.6 本章小结

• Goroutine 是构建高并发搜索系统的基石，轻量且高效，但需通过 sync.WaitGroup 或 errgroup 管理生命周期。
• Channel 提供 Goroutine 间的安全通信，无缓冲 Channel 用于同步，有缓冲 Channel 用于解耦生产消费速率。
• select 多路复用是实现超时控制、优雅退出和请求折叠的核心语法，配合 time.After 或 time.NewTimer 使用。
• context 包提供请求级生命周期管理，WithTimeout 和 WithCancel 是尾延迟优化的关键工具，级联取消机制可有效释放系统资源。