并行子测试为什么会拿到同一个循环变量，应该怎样隔离数据

并行子测试“都拿到同一个循环变量”，通常不是 t.Run 随机传错参数，而是闭包捕获了循环变量。旧版 Go 语义中，循环变量只有一个存储位置；调用 t.Parallel() 后，子测试会暂停，等父测试函数返回才继续执行。循环此时往往已经结束，于是多个闭包都读到最后一次赋值。

兼容旧模块时，在循环体第一行写 tc := tc，为本轮创建新变量。Go 1.22 及更高语言版本已经按轮创建循环变量，但这只解决变量捕获；若测试项含 slice、map、pointer 或共享文件，仍要单独复制或重新创建资源。

问题：为什么 t.Parallel 会放大循环变量错误

表驱动测试常把当前测试项传给 t.Run 的闭包。若循环变量在各轮复用，闭包捕获的是同一个变量，而不是注册子测试那一刻的值。普通子测试可能立即执行，问题有时不明显；并行子测试调用 t.Parallel() 后会先暂停，等外层测试函数完成后再进入并行阶段，这时循环变量已经更新到最后一项。

func TestValidate(t *testing.T) {
    tests := []struct {
        name string
        value int
        want bool
    }{
        {name: "negative", value: -1, want: false},
        {name: "zero", value: 0, want: true},
        {name: "positive", value: 1, want: true},
    }

    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            t.Parallel() // 子测试在这里暂停，父测试循环可能先走完
            got := tc.value >= 0 // 旧循环语义下可能总是读取最后一个 tc
            if got != tc.want {
                t.Fatalf("got %v, want %v", got, tc.want) // 报告当前子测试结果
            }
        })
    }
}

这种错误更危险的地方是“假通过”。如果最后一个测试项恰好通过，所有子测试可能重复验证它，而本应失败的前几项根本没有真正被检查。子测试名称仍来自注册 t.Run 时求值的参数，所以日志看起来像跑了三组，闭包内部却可能都在读取最后一组数据。

最小配方：在循环内固定本轮测试项

需要兼容旧模块语义时，最直接的修复是在循环体内重新声明同名变量。右侧的 tc 先读取当前循环项，左侧的 tc 再创建一个属于本轮的新变量，后面的闭包捕获新变量。

for _, tc := range tests {
    tc := tc // 为当前迭代创建独立变量，兼容 Go 1.22 之前的循环语义

    t.Run(tc.name, func(t *testing.T) {
        t.Parallel() // 闭包捕获的是当前迭代新建的 tc
        got := tc.value >= 0 // 每个子测试读取自己的测试项
        if got != tc.want {
            t.Fatalf("got %v, want %v", got, tc.want) // 输出当前用例的期望值
        }
    })
}

Go 1.22 改变了 for 循环变量语义：每次迭代都会创建新变量，从语言层面消除这类意外共享。是否采用新语义由包所属模块的 go.mod 语言版本决定；声明 go 1.22 或更高版本的模块使用新语义，旧语言版本代码仍保留旧含义。因此，在需要跨版本复制代码、维护旧模块或阅读历史测试时，tc := tc 仍是一条清晰的兼容配方。

关键边界：tc := tc 只是浅复制

重新绑定测试项解决的是“闭包是否共享同一个结构体变量”，并不自动复制结构体字段指向的底层数据。整数、布尔值和字符串头会随结构体值复制；slice、map、pointer、channel 和函数值仍可能指向同一份状态。若被测函数会原地修改 slice，两个测试项又复用了同一个底层数组，仅写 tc := tc 依然可能互相干扰。

func TestNormalize(t *testing.T) {
    shared := []int{3, 1, 2} // 两个测试项故意引用同一个底层数组
    tests := []struct {
        name  string
        input []int
        want  int
    }{
        {name: "all", input: shared, want: 6},
        {name: "prefix", input: shared[:2], want: 4},
    }

    for _, tc := range tests {
        tc := tc // 只复制结构体和 slice 头，不复制底层数组
        t.Run(tc.name, func(t *testing.T) {
            t.Parallel()
            input := append([]int(nil), tc.input...) // 为当前子测试复制底层元素
            got := normalizeAndSum(input) // 被测函数可以安全地原地修改 input
            if got != tc.want {
                t.Fatalf("got %d, want %d", got, tc.want) // 只报告本用例结果
            }
        })
    }
}

map 需要逐项复制，指针指向可变对象时需要复制对象或构造新对象；如果函数通过闭包访问外部计数器、缓存或 mock 状态，也应让每个子测试拥有独立实例。隔离的判断标准不是“结构体看起来已经复制”，而是并行代码能否通过任意引用路径修改同一块状态。

变体：文件、端口和全局状态也要按子测试隔离

并行测试的冲突不只来自内存字段。多个子测试写同一路径、复用同一数据库记录、绑定同一固定端口或修改同一个全局变量，也会产生不稳定结果。优先在子测试内部创建资源，并让资源生命周期跟随当前 *testing.T。

for _, tc := range tests {
    tc := tc // 旧模块兼容：固定当前循环项
    t.Run(tc.name, func(t *testing.T) {
        t.Parallel()

        workDir := t.TempDir() // 每个子测试获得独立临时目录并自动清理
        store := newMemoryStore() // 每个子测试创建独立存储，不共享全局实例
        result := runCase(workDir, store, tc.input) // 只传入本测试拥有的资源

        if result != tc.want {
            t.Fatalf("got %v, want %v", result, tc.want) // 保留明确断言信息
        }
    })
}

如果确实需要共享只读夹具，应在并行开始前完成构造，之后不再修改；如果共享对象必须写入，就使用清晰的同步机制，并确认测试是在验证并发行为，而不是无意间让普通用例互相耦合。

兼容坑：先看 go.mod，再区分三类故障

go vet 的 loopclosure 检查可以发现一部分旧语义下的高概率捕获问题，但它不能替代数据所有权设计。Go 1.22 新语义下，单纯捕获按轮变量已经安全，分析器也不会把这类情况继续视为错误；引用字段和外部资源是否共享，仍需要结合被测函数行为判断。

完整片段：同时固定循环项和可变输入

func TestNormalizeAndSum(t *testing.T) {
    shared := []int{3, 1, 2} // 构造一个容易暴露共享问题的输入
    tests := []struct {
        name  string
        input []int
        want  int
    }{
        {name: "all", input: shared, want: 6},
        {name: "prefix", input: shared[:2], want: 4},
    }

    for _, tc := range tests {
        tc := tc // 固定本轮结构体，兼容旧循环变量语义

        t.Run(tc.name, func(t *testing.T) {
            t.Parallel()
            input := append([]int(nil), tc.input...) // 复制 slice 底层数据
            workDir := t.TempDir() // 为当前子测试创建独占文件目录

            got := normalizeAndSumInDir(workDir, input) // 被测函数可修改自己的输入
            if got != tc.want {
                t.Fatalf("got %d, want %d", got, tc.want) // 精确定位失败用例
            }
        })
    }
}

排查顺序可以固定为三步：先确认模块是否启用 Go 1.22 循环语义，再检查闭包是否捕获旧版循环变量，最后沿着 slice、map、pointer 和外部资源追踪可变状态。只补一行 tc := tc 能解决第一类问题，却不能替代并行测试所需的数据隔离。

相关问题

Go 1.22 以后还要不要写 tc := tc？ 对声明 Go 1.22 或更高语言版本的包，循环变量已经按轮创建，单纯为了避免该变量捕获不再需要；如果代码要兼容旧模块，保留这行仍有明确价值。

为什么子测试名称不同，内部数据却相同？ t.Run(tc.name, ...) 的名称参数在注册时求值，而闭包里的 tc 可能稍后才读取，因此名称和闭包数据可以来自不同时间点。

加锁能不能代替复制？ 加锁只能控制并发访问，不能让测试用例彼此独立。普通表驱动测试优先使用独占数据；只有测试目标本身就是共享并发状态时，才应把共享与同步写进测试设计。