Go语言并发与锁机制的测试策略与最佳实践

package main

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

// -----------------------------------------------------------
// 模拟的分布式锁客户端 (Mock Client for demonstration)
// 在实际应用中，NewClient和Lock/Unlock会是与实际分布式锁服务（如Redis, ZooKeeper）交互的实现。
// 此处使用一个全局的sync.Mutex来模拟分布式锁的互斥性，以便测试其行为逻辑。
// -----------------------------------------------------------

var (
    mockGlobalLock      sync.Mutex // 模拟分布式锁的互斥性
    mockCurrentLockKey  string
    mockLockHolderID    int64
    mockNextLockID      int64 = 1
)

type MockClient struct{}

func NewClient() (*MockClient, error) {
    return &MockClient{}, nil
}

func (c *MockClient) Lock(lockKey string, timeout time.Duration) (int64, error) {
    start := time.Now()
    for {
        mockGlobalLock.Lock() // 尝试获取模拟的全局锁
        if mockCurrentLockKey == "" || mockCurrentLockKey == lockKey {
            // 如果锁未被持有，或者被当前请求的key持有（重入或测试特定场景）
            // 在此简化为：如果锁未被持有，则获取
            if mockCurrentLockKey == "" {
                mockCurrentLockKey = lockKey
                mockLockHolderID = mockNextLockID
                mockNextLockID++
                id := mockLockHolderID
                mockGlobalLock.Unlock()
                return id, nil
            }
        }
        mockGlobalLock.Unlock() // 未能获取锁，释放模拟锁，等待重试

        // 模拟等待或重试机制
        time.Sleep(10 * time.Millisecond) 
        if time.Since(start) > timeout {
            return 0, fmt.Errorf("lock acquisition timed out for key %s", lockKey)
        }
    }
}

func (c *MockClient) Unlock(lockKey string, id int64) error {
    mockGlobalLock.Lock()
    defer mockGlobalLock.Unlock()
    if mockCurrentLockKey == lockKey && mockLockHolderID == id {
        mockCurrentLockKey = ""
        mockLockHolderID = 0
        return nil
    }
    return fmt.Errorf("unlock failed: key %s not held by ID %d", lockKey, id)
}

func (c *MockClient) Close() error {
    // 模拟关闭客户端连接
    return nil
}

// -----------------------------------------------------------
// 自动化测试函数
// -----------------------------------------------------------

func TestLockUnlockAutomated(t *testing.T) {
    // 初始化模拟锁状态
    mockGlobalLock.Lock()
    mockCurrentLockKey = ""
    mockLockHolderID = 0
    mockNextLockID = 1
    mockGlobalLock.Unlock()

    // 用于同步事件的通道
    client1GotLock := make(chan struct{})      // client1 成功获取锁
    client2TriedToLock := make(chan struct{})  // client2 尝试获取锁
    client2GotLock := make(chan struct{})      // client2 成功获取锁
    client1ReleasedLock := make(chan struct{}) // client1 释放锁

    var wg sync.WaitGroup
    wg.Add(2) // 两个客户端 Goroutine

    // 客户端 1 Goroutine
    go func() {
        defer wg.Done()
        client1, err := NewClient()
        if err != nil {
            t.Errorf("Client 1: Unexpected new client error: %v", err)
            return
        }
        defer client1.Close()

        t.Log("Client 1 attempting to get lock 'x'")
        id1, err := client1.Lock("x", 5*time.Second)
        if err != nil {
            t.Errorf("Client 1: Unexpected lock error: %v", err)
            return
        }
        t.Logf("Client 1 got lock 'x' with ID %d", id1)
        close(client1GotLock) // 信号：client1 已获取锁

        // 等待 client2 尝试获取锁的信号
        select {
        case <-client2TriedToLock:
            t.Log("Client 1 observed client 2 tried to get lock")
        case <-time.After(2 * time.Second):
            t.Error("Client 1: Timed out waiting for client 2 to try to lock")
            return
        }

        // 模拟 client1 持有锁期间的一些操作
        time.Sleep(100 * time.Millisecond)

        t.Log("Client 1 releasing lock 'x'")
        err = client1.Unlock("x", id1)
        if err != nil {
            t.Errorf("Client 1: Unexpected unlock error: %v", err)
        }
        t.Log("Client 1 released lock 'x'")
        close(client1ReleasedLock) // 信号：client1 已释放锁
    }()

    // 客户端 2 Goroutine
    go func() {
        defer wg.Done()
        client2, err := NewClient()
        if err != nil {
            t.Errorf("Client 2: Unexpected new client error: %v", err)
            return
        }
        defer client2.Close()

        // 等待 client1 获取锁的信号，确保 client1 先拿到锁
        select {
        case <-client1GotLock:
            t.Log("Client 2 observed client 1 got lock")
        case <-time.After(2 * time.Second):
            t.Error("Client 2: Timed out waiting for client 1 to get lock")
            return
        }

        t.Log("Client 2 attempting to get lock 'x'")
        close(client2TriedToLock) // 信号：client2 尝试获取锁

        // client2 尝试获取锁，这里应该阻塞直到 client1 释放
        id2, err := client2.Lock("x", 5*time.Second)
        if err != nil {
            t.Errorf("Client 2: Unexpected lock error: %v", err)
            return
        }
        t.Logf("Client 2 got lock 'x' with ID %d", id2)
        close(client2GotLock) // 信号：client2 已获取锁

        // 断言：client2 必须在 client1 释放锁之后才能获取锁
        select {
        case <-client1ReleasedLock:
            // 这是期望的路径：client1 释放后，client2 才获取
            t.Log("Client 2 successfully acquired lock after client 1 released.")
        case <-time.After(10 * time.Millisecond): // 短暂等待，确保信号已传递
            // 如果 client2 在 client1 释放前就获取了锁，说明锁机制有缺陷
            t.Error("Client 2 acquired lock before client 1 released it, indicating a potential race or incorrect lock mechanism.")
        }

        t.Log("Client 2 releasing lock 'x'")
        err = client2.Unlock("x", id2)
        if err != nil {
            t.Errorf("Client 2: Unexpected unlock error: %v", err)
        }
        t.Log("Client 2 released lock 'x'")
    }()

    // 等待所有 Goroutine 完成
    wg.Wait()

    // 最终检查，确保所有关键事件都已发生且顺序正确
    select {
    case <-client2GotLock:
        // client2 成功获取并释放锁，说明整个流程完成
    case <-time.After(10 * time.Second):
        t.Fatal("Test timed out waiting for client 2 to acquire/release lock, indicating a potential deadlock or hang.")
    }
}