Go 基础回顾：核心特性、Goroutine 与 Channel 在压测中的应用

在构建服务契约压测闭环之前，扎实的 Go 语言基础是编写高效、可靠压测脚本的前提。本节将聚焦 Go 语言的核心特性，重点剖析 Goroutine 与 Channel 在并发压测场景下的设计模式与实战技巧。

Go 语言核心特性概览

Go 语言的设计哲学强调简洁、高效与内置并发。以下表格对比了 Go 在压测场景中最为关键的几个特性：

Goroutine：压测并发的基本单元

Goroutine 是 Go 运行时管理的轻量级执行体。在压测脚本中，每个 Goroutine 通常代表一个虚拟用户（VU），独立执行请求序列。

// 示例：启动多个 Goroutine 模拟并发用户
func main() {
    var wg sync.WaitGroup
    concurrency := 100 // 并发用户数

    for i := 0; i < concurrency; i++ {
        wg.Add(1)
        go func(userID int) {
            defer wg.Done()
            // 模拟单个用户的请求序列
            for j := 0; j < 10; j++ {
                // 执行 HTTP 请求
                resp, err := http.Get("http://target-service/api/health")
                if err != nil {
                    log.Printf("User %d, request %d failed: %v", userID, j, err)
                    continue
                }
                resp.Body.Close()
            }
        }(i)
    }
    wg.Wait()
    fmt.Println("所有并发用户执行完毕")
}

Channel：压测协程间的通信桥梁

Channel 用于在 Goroutine 之间安全地传递数据。在压测场景中，Channel 常用于收集各虚拟用户的执行结果、控制并发速率以及实现优雅退出。

结果收集模式

使用带缓冲的 Channel 收集所有 Goroutine 的测试结果，避免在统计阶段产生锁竞争。

type Result struct {
    UserID   int
    Success  bool
    Duration time.Duration
}

func main() {
    const numUsers = 50
    results := make(chan Result, numUsers) // 缓冲 Channel

    var wg sync.WaitGroup
    for i := 0; i < numUsers; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            start := time.Now()
            // 模拟请求
            time.Sleep(time.Millisecond * time.Duration(100+id%50))
            results <- Result{
                UserID:   id,
                Success:  true,
                Duration: time.Since(start),
            }
        }(i)
    }

    // 等待所有 Goroutine 完成，然后关闭 Channel
    go func() {
        wg.Wait()
        close(results)
    }()

    // 主 Goroutine 读取并统计结果
    var totalDuration time.Duration
    var count int
    for r := range results {
        totalDuration += r.Duration
        count++
        fmt.Printf("User %d: %v\n", r.UserID, r.Duration)
    }
    fmt.Printf("平均响应时间: %v\n", totalDuration/time.Duration(count))
}

Goroutine 与 Channel 在压测中的协作模式

下图展示了压测脚本中 Goroutine 与 Channel 的典型协作架构：

select 多路复用与超时控制

在压测中，超时控制是保证测试稳定性的关键。使用 select 语句可以同时监听多个 Channel，实现灵活的等待与超时逻辑。

func executeWithTimeout(timeout time.Duration) (bool, error) {
    result := make(chan bool, 1)
    
    go func() {
        // 模拟耗时请求
        time.Sleep(200 * time.Millisecond)
        result <- true
    }()

    select {
    case res := <-result:
        return res, nil
    case <-time.After(timeout):
        return false, fmt.Errorf("请求超时")
    }
}

// 在压测循环中使用
for i := 0; i < 100; i++ {
    success, err := executeWithTimeout(150 * time.Millisecond)
    if err != nil {
        log.Printf("请求 %d 超时: %v", i, err)
    } else {
        log.Printf("请求 %d 成功: %v", i, success)
    }
}

sync.WaitGroup 与并发控制

WaitGroup 是压测脚本中管理 Goroutine 生命周期的核心工具。它确保主 Goroutine 在所有虚拟用户执行完毕后才进行结果汇总。

Goroutine 泄漏检测与预防

压测脚本长时间运行，Goroutine 泄漏会导致内存持续增长，最终影响测试结果。以下场景容易引发泄漏：

• Channel 未关闭： 发送方未关闭 Channel，接收方一直阻塞等待。
• select 缺少 default： 所有 Channel 都不可用时，Goroutine 永久阻塞。
• 无限循环缺少退出条件： Goroutine 内部循环没有监听退出信号。

// 安全的 Goroutine 模式：使用退出 Channel
func safeWorker(ctx context.Context, id int, results chan<- int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d 退出\n", id)
            return
        default:
            // 执行任务
            results <- id * 10
            time.Sleep(100 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    results := make(chan int, 10)
    for i := 0; i < 5; i++ {
        go safeWorker(ctx, i, results)
    }

    // 读取结果直到超时
    for {
        select {
        case r := <-results:
            fmt.Printf("收到结果: %d\n", r)
        case <-ctx.Done():
            fmt.Println("超时，停止接收")
            return
        }
    }
}

压测中的并发安全

多个 Goroutine 同时访问共享变量时，必须使用同步机制。下表对比了压测中常用的并发安全方案：