如何测试代码是否启动Goroutine？编写验证Goroutine创建的测试用例

嘿，这两个问题本质上是一回事儿——核心就是如何在Go测试里确认目标Goroutine确实被创建并启动了。我来分享几个实战中常用的靠谱方法，都是Go测试圈里的常规操作：

这是最直观也最可靠的方式之一。思路是让被测试的Goroutine在启动后（或者完成核心逻辑后）向一个通道发送信号，测试用例通过接收这个信号来确认Goroutine真的跑起来了。

举个例子，假设我们有个启动worker的函数：

// 被测试函数：启动一个worker Goroutine
func StartWorker() chan struct{} {
    done := make(chan struct{})
    go func() {
        // 这里写worker的核心逻辑，比如监听任务、处理数据
        defer close(done) // 逻辑结束后关闭通道
    }()
    return done
}

对应的测试用例可以这么写：

import (
    "testing"
    "time"
)

func TestStartWorker(t *testing.T) {
    done := StartWorker()

    // 用select加超时，防止测试无限挂起
    select {
    case <-done:
        // 成功接收到通道关闭信号，说明Goroutine确实启动并执行完成了
    case <-time.After(time.Second):
        t.Error("Goroutine没在预期时间内启动或完成，大概率是没跑起来")
    }
}

如果你的Goroutine是长期运行的（比如后台服务的常驻worker），可以改成让它接收一个停止信号，测试时发送停止信号并等待退出，同样能验证它在运行：

func StartLongRunningWorker(stop chan struct{}) {
    go func() {
        for {
            select {
            case <-stop:
                return
            default:
                // 执行常驻逻辑
            }
        }
    }()
}

func TestLongRunningWorker(t *testing.T) {
    stop := make(chan struct{})
    StartLongRunningWorker(stop)

    // 短暂等待让Goroutine启动
    time.Sleep(100 * time.Millisecond)
    
    // 发送停止信号并等待
    close(stop)
    // 这里如果Goroutine正常响应停止，说明它确实在运行
}

如果你的Goroutine是用来处理一批任务的，用WaitGroup会更合适——它能帮你等待所有Goroutine完成任务，间接验证Goroutine被创建并执行了。

比如被测试的代码：

import "sync"

func processTask(task string) {
    // 单个任务的处理逻辑
}

// 启动一个Goroutine处理任务列表
func StartTaskProcessor(tasks []string) *sync.WaitGroup {
    wg := &sync.WaitGroup{}
    wg.Add(1)
    go func() {
        defer wg.Done()
        for _, task := range tasks {
            processTask(task)
        }
    }()
    return wg
}

测试用例：

func TestStartTaskProcessor(t *testing.T) {
    tasks := []string{"task1", "task2", "task3"}
    wg := StartTaskProcessor(tasks)

    // 用一个超时协程防止Wait无限挂起
    timeoutChan := make(chan bool, 1)
    go func() {
        wg.Wait()
        timeoutChan <- true
    }()

    select {
    case <-timeoutChan:
        // WaitGroup完成，说明Goroutine确实启动并处理完了所有任务
    case <-time.After(2 * time.Second):
        t.Error("Goroutine处理超时，可能根本没启动")
    }
}

这个方法比较直接——先获取当前Goroutine的数量，调用启动函数后再统计一次，看数量是否增加。不过要注意，这个方法有一定局限性，因为测试本身、Go的GC等也会启动额外的Goroutine，所以适合简单场景或者作为辅助验证。

示例代码：

import (
    "testing"
    "runtime"
    "time"
)

func StartSomeGoroutine() {
    go func() {
        // 随便做点什么，比如sleep模拟运行
        time.Sleep(500 * time.Millisecond)
    }()
}

func TestGoroutineCount(t *testing.T) {
    // 获取初始Goroutine数量（测试主协程本身也算一个）
    initialCount := runtime.NumGoroutine()

    // 调用启动函数
    StartSomeGoroutine()

    // 短暂等待，让Goroutine有机会启动
    time.Sleep(100 * time.Millisecond)

    finalCount := runtime.NumGoroutine()
    if finalCount <= initialCount {
        t.Errorf("预期Goroutine数量增加，但初始为%d，最终为%d", initialCount, finalCount)
    }
}

一些额外注意事项 #

• 优先用通道或WaitGroup的方法，这两种能直接关联到目标Goroutine的状态，比统计数量更可靠。
• 一定要加超时！不管用哪种方法，都要避免测试用例因为Goroutine没启动而无限挂起，浪费时间。
• 如果测试的是并发场景，要考虑竞态条件，必要时可以用-race参数开启竞态检测。

内容的提问来源于stack exchange，提问作者warlord -x