Golang中如何对并发数据结构进行单元测试

在Golang中对并发数据结构进行单元测试，通常需要结合多种测试策略来确保线程安全。以下是我推荐的测试方法及示例代码：

1. 竞态条件检测

使用-race标志运行测试，这是最基本且必要的步骤：

go test -race ./...

2. 并发压力测试

模拟多个goroutine同时访问数据结构：

func TestConcurrentAccess(t *testing.T) {
    d := NewD()
    var wg sync.WaitGroup
    iterations := 1000
    goroutines := 100

    for i := 0; i < goroutines; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < iterations; j++ {
                key := fmt.Sprintf("key-%d-%d", id, j)
                d.Set(key, j)
                val, ok := d.Get(key)
                if !ok || val != j {
                    t.Errorf("数据不一致: key=%s, expected=%d, got=%v", key, j, val)
                }
                d.Delete(key)
            }
        }(i)
    }
    wg.Wait()
}

3. 顺序一致性测试

验证操作在并发环境下的顺序一致性：

func TestSequentialConsistency(t *testing.T) {
    d := NewD()
    const N = 10000
    var wg sync.WaitGroup
    results := make(chan int, N)

    // 并发写入
    for i := 0; i < N; i++ {
        wg.Add(1)
        go func(val int) {
            defer wg.Done()
            d.Set("counter", val)
            results <- d.Get("counter")
        }(i)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    // 验证读取的值是有效的
    for val := range results {
        if val < 0 || val >= N {
            t.Errorf("无效的值: %d", val)
        }
    }
}

4. 死锁检测测试

func TestDeadlockFreedom(t *testing.T) {
    d := NewD()
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    done := make(chan bool)
    
    go func() {
        // 模拟复杂并发操作
        var wg sync.WaitGroup
        for i := 0; i < 100; i++ {
            wg.Add(1)
            go func(id int) {
                defer wg.Done()
                for j := 0; j < 100; j++ {
                    d.Set(fmt.Sprintf("%d-%d", id, j), j)
                    d.Get(fmt.Sprintf("%d-%d", id, j))
                }
            }(i)
        }
        wg.Wait()
        done <- true
    }()

    select {
    case <-ctx.Done():
        t.Fatal("测试超时，可能存在死锁")
    case <-done:
        // 正常完成
    }
}

5. 边界条件并发测试

func TestBoundaryConditions(t *testing.T) {
    d := NewD()
    
    // 测试空数据结构的并发访问
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(2)
        go func() {
            defer wg.Done()
            d.Get("nonexistent")
        }()
        go func() {
            defer wg.Done()
            d.Delete("nonexistent")
        }()
    }
    wg.Wait()
}

6. 混合操作测试

func TestMixedOperations(t *testing.T) {
    d := NewD()
    const workers = 50
    var wg sync.WaitGroup
    errors := make(chan error, workers*100)

    for w := 0; w < workers; w++ {
        wg.Add(1)
        go func(workerID int) {
            defer wg.Done()
            for i := 0; i < 100; i++ {
                key := fmt.Sprintf("key-%d", i)
                
                // 混合操作序列
                d.Set(key, workerID)
                val, ok := d.Get(key)
                if ok && val != workerID {
                    errors <- fmt.Errorf("worker %d: 期望 %d, 得到 %d", workerID, workerID, val)
                }
                
                d.Update(key, func(old int) int {
                    return old + 1
                })
                
                d.Delete(key)
                
                // 验证删除
                if _, ok := d.Get(key); ok {
                    errors <- fmt.Errorf("key %s 应该已被删除", key)
                }
            }
        }(w)
    }

    wg.Wait()
    close(errors)
    
    for err := range errors {
        t.Error(err)
    }
}

7. 性能基准测试

func BenchmarkConcurrentAccess(b *testing.B) {
    d := NewD()
    b.RunParallel(func(pb *testing.PB) {
        counter := 0
        for pb.Next() {
            key := fmt.Sprintf("key-%d", counter%1000)
            d.Set(key, counter)
            d.Get(key)
            counter++
        }
    })
}

这些测试组合使用可以有效地发现并发问题：

• 竞态检测器捕获数据竞争
• 压力测试暴露同步问题
• 超时测试检测死锁
• 混合操作测试验证复杂场景
• 基准测试确保性能可接受

运行测试时务必使用-race标志，并在CI/CD流水线中强制执行这些测试。