如何解决Go测试中协程失败引发的死锁问题

针对你遇到的两个测试goroutine同步死锁、以及TestA需随TestB失败而失败的问题，以下是可行的解决方案及原方案问题分析：

原方案核心问题 #

1. 全局testing.T指针不安全：*testing.T并非并发安全类型，直接全局共享并调用Fail()会引发竞态问题。
2. Cleanup逻辑错误：t.Cleanup()会在测试结束时无论成功失败都执行，导致即使TestB无错误，TestA也会被标记失败。
3. 无超时保护：若TestB意外崩溃，TestA会因一直等待cond.Wait()陷入死锁。
4. 未处理虚假唤醒：sync.Cond的Wait()可能被虚假唤醒，直接等待而非循环检查条件会导致逻辑异常。

方案一：基于sync.Cond的改进实现 #

通过封装共享状态与同步原语，结合超时与条件循环检查，解决死锁与失败同步问题：

package yourpackage

import (
    "sync"
    "testing"
    "time"
)

type testSync struct {
    mu      sync.Mutex
    cond    *sync.Cond
    bFailed bool
}

var ts testSync

func init() {
    ts.cond = sync.NewCond(&ts.mu)
}

func TestFunctionA(t *testing.T) {
    t.Parallel() // 开启并行测试，与TestB并发执行

    ts.mu.Lock()
    defer ts.mu.Unlock()

    // 循环检查条件+超时，避免虚假唤醒与无限等待
    for !ts.bFailed {
        done := make(chan struct{})
        go func() {
            ts.cond.Wait()
            close(done)
        }()

        select {
        case <-done:
        case <-time.After(5 * time.Second): // 可根据测试场景调整超时时间
            t.Fatal("TestA等待超时，TestB可能未正常执行")
        }
    }

    // 若TestB失败，标记TestA为失败
    if ts.bFailed {
        t.Fail()
    }
}

func TestFunctionB(t *testing.T) {
    t.Parallel()

    ts.mu.Lock()
    defer ts.mu.Unlock()

    // 模拟测试逻辑，此处设置failed为true模拟失败
    failed := false
    // ... 你的测试代码，根据结果修改failed的值
    failed = true

    if failed {
        ts.bFailed = true
        t.Fail()
    }

    // 广播唤醒所有等待的goroutine
    ts.cond.Broadcast()
}

方案优势 #

• 用结构体封装同步原语与状态，避免全局变量混乱
• 循环检查条件处理sync.Cond的虚假唤醒问题
• 超时机制防止TestB崩溃导致TestA死锁
• 并发安全的状态传递，避免直接操作testing.T

方案二：基于context.Context的更简洁实现 #

利用Go标准库的context取消机制替代sync.Cond，更符合Go并发编程范式：

package yourpackage

import (
    "context"
    "sync"
    "testing"
    "time"
)

var (
    testCtx    context.Context
    testCancel context.CancelFunc
    stateMu    sync.Mutex
    bFailed    bool
)

func init() {
    testCtx, testCancel = context.WithCancel(context.Background())
}

func TestFunctionA(t *testing.T) {
    t.Parallel()

    select {
    case <-testCtx.Done():
        // 检查TestB的失败状态
        stateMu.Lock()
        defer stateMu.Unlock()
        if bFailed {
            t.Fail()
        }
    case <-time.After(5 * time.Second):
        t.Fatal("TestA等待超时")
    }
}

func TestFunctionB(t *testing.T) {
    t.Parallel()
    defer testCancel() // 无论成功失败，结束时取消context唤醒TestA

    // 模拟测试逻辑
    failed := false
    // ... 你的测试代码
    failed = true

    // 并发安全地更新失败状态
    stateMu.Lock()
    bFailed = failed
    stateMu.Unlock()

    if failed {
        t.Fail()
    }
}

方案优势 #

• 用context生命周期管理替代传统条件变量，代码更简洁
• defer testCancel()确保TestB无论结果如何都会唤醒TestA，彻底避免死锁
• 互斥锁保护状态，保证并发安全

关键注意事项 #

1. 若需两个Test函数并发执行，必须调用t.Parallel()，否则Go测试默认串行执行Test函数
2. 禁止直接共享*testing.T指针，所有测试状态需通过并发安全的方式传递
3. 超时时间需根据实际测试场景调整，平衡测试稳定性与执行效率

内容的提问来源于stack exchange，提问作者WeiAnHsieh