Go 子测试使用 t.Parallel 时怎么隔离共享数据

把 Go 的表驱动测试改成并行子测试时，关键不是在循环里补上一句 t.Parallel()，而是先划清数据所有权：每个子测试独有的 map、slice、缓冲区和临时夹具必须在自己的边界内创建；确实要共享的状态，则用锁或其他同步手段保护。这样既能提高测试吞吐，也不会把一个用例的写入带到另一个用例。

先把每个子测试的输入和可变状态分开

t.Parallel() 标记的是当前子测试，不是外层循环，也不会自动复制闭包里的变量。下面用一个小型折扣计算测试说明最小写法：测试表只保存输入，真正会被修改的结果变量在子测试内部创建。

package discount

import "testing"

func calcDiscount(amount int, vip bool) int {
    if vip {
        return amount * 90 / 100 // 会员按九折计算，结果保持整数
    }
    return amount
}

func TestDiscountParallel(t *testing.T) {
    cases := []struct {
        name   string
        amount int
        vip    bool
        want   int
    }{
        {name: "普通用户", amount: 100, vip: false, want: 100},
        {name: "会员用户", amount: 100, vip: true, want: 90},
    }

    for _, tc := range cases {
        tc := tc // 兼容旧版 Go，并明确把当前用例绑定到闭包
        t.Run(tc.name, func(t *testing.T) {
            t.Parallel() // 只暂停当前子测试，不改变测试表的所有权

            got := calcDiscount(tc.amount, tc.vip) // 结果变量属于当前子测试
            if got != tc.want {
                t.Fatalf("got %d, want %d", got, tc.want) // 失败只报告当前用例
            }
        })
    }
}

这里的 tc := tc 是闭包绑定，不是并发锁。Go 1.22 改变了满足新模块语义的循环变量作用域，但显式绑定仍能清楚表达代码意图。更重要的是，不要把一个会被子测试修改的公共 slice 或 map直接放进闭包；即使测试偶尔通过，也可能在竞态检查或并发度变化后暴露问题。

必须共享时用受保护的测试夹具

有些测试确实要验证多个用例对同一份资源的访问，例如共享缓存、计数器或内存仓库。此时共享本身不是错误，未定义访问规则才是错误。把锁和资源一起放在父测试里，并让子测试在锁的保护范围内读写。

import (
    "fmt"
    "sync"
    "testing"
)

func TestSharedFixture(t *testing.T) {
    var mu sync.Mutex
    sharedStore := map[string]int{"processed": 0}
    cases := []int{1, 2, 3, 4}

    for _, id := range cases {
        id := id // 每个并行子测试只绑定自己的标识
        t.Run(fmt.Sprintf("case-%d", id), func(t *testing.T) {
            t.Parallel()

            mu.Lock() // 共享 map 的读写必须成对进入临界区
            sharedStore["processed"]++
            mu.Unlock()
        })
    }

    // t.Run 返回后，所有并行子测试已经结束，可以安全汇总。
    if sharedStore["processed"] != len(cases) {
        t.Fatalf("processed=%d, want %d", sharedStore["processed"], len(cases))
    }
}

示例还需要导入 fmt、sync 和 testing。如果共享资源涉及文件、临时目录或连接，应在创建它的层级注册 t.Cleanup，不要让某个并行子测试提前删除其他用例仍在使用的资源。只读共享配置通常不需要锁，但配置引用的底层 slice、map 不能在测试期间被修改。

用 -race 和 -run 验收隔离是否成立

先用层级化名称缩小范围，再提高并发度观察是否稳定。-parallel 只控制同一测试二进制中的并行测试数量，不能替代数据同步；-race 才会帮助发现共享内存的竞态访问。

# 先只运行折扣测试，确认子测试名称和断言范围
go test -run '^TestDiscountParallel$' -v

# 使用竞态检测并提高同一测试二进制的并发度
go test -race -run '^TestDiscountParallel$' -parallel 4

# 最后覆盖整个包，避免另一个测试与共享夹具冲突
go test -race ./...

常见问题

调用 t.Parallel 后是不是所有子测试马上同时执行？

不是。并行子测试会等待非并行测试完成，实际并发还受 -parallel 限制；父级 t.Run 返回前会等待它创建的并行子测试结束。

只读的测试表也需要复制吗？

如果整个测试期间确实只读，通常可以共享；但表中嵌套的 map、slice 或指针仍可能被辅助函数修改。遇到这种 API，优先为每个子测试创建独立夹具。

加了 t.Parallel 还需要 go test -race 吗？

需要。t.Parallel()只改变调度关系，不会为 map、slice、全局变量或外部资源提供同步。用 -race 检查并行测试与被测代码的共享内存访问，才能确认隔离方案没有遗漏。

归根结底，安全的并行子测试有三条线：输入按用例绑定，可变状态按用例拥有，共享资源由锁和生命周期共同管理。先画清这三条线，再调高 -parallel，测试速度和可信度才能同时保住。