C++中TAS和CAS实现自旋锁的示例

#include <atomic>
#include <thread>
#include <iostream>

//intel指令
#include <immintrin.h>
//_mm_pause();  // 和 pause 汇编完全一样

// 自旋等待优化（x86）
#define asm_volatile_pause() asm volatile ("pause")

// --------------------------
// TAS 实现：极简自旋锁
// 场景：临界区极短、低并发、追求代码最简单
// --------------------------
class TasSpinLock {
private:
    // C++ 原生 TAS 原子变量（硬件直接支持）
    std::atomic_flag lock_ = ATOMIC_FLAG_INIT;

public:
    void lock() {
        // TAS 核心：test_and_set = 原子读旧值 + 强制写true
        while (lock_.test_and_set(std::memory_order_acquire)) {
            asm_volatile_pause(); // 自旋优化
        }
    }

    void unlock() {
        lock_.clear(std::memory_order_release);
    }
};

// 测试：多线程计数
int cnt = 0;
TasSpinLock tas_lock;

void work() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<TasSpinLock> guard(tas_lock);
        cnt++;
    }
}

int main() {
    std::thread t1(work), t2(work);
    t1.join(); t2.join();
    std::cout << "TAS 自旋锁结果: " << cnt << std::endl; // 200000
    return 0;
}

// --------------------------
// CAS 实现：高性能自旋锁
// 场景：多核高并发、低延迟临界区
// --------------------------
class CasSpinLock {
private:
    std::atomic<bool> locked_{false};

public:
    void lock() {
        bool expected = false;
        // CAS 核心：只有值=expected(false)，才写入true
        while (!locked_.compare_exchange_weak(
            expected, true,
            std::memory_order_acquire
        )) {
            expected = false; // 重置期望值
            asm_volatile_pause();
        }
    }

    void unlock() {
        locked_.store(false, std::memory_order_release);
    }
};

// --------------------------
// CAS 实现：无锁原子计数器
// 场景：高并发计数（无锁、高性能）
// --------------------------
std::atomic<int> cas_cnt{0};

void lock_free_count() {
    int old_val, new_val;
    for (int i = 0; i < 100000; ++i) {
        do {
            old_val = cas_cnt;    // 读旧值
            new_val = old_val + 1;// 计算新值
        // CAS：只有旧值没被修改，才更新成功
        } while (!cas_cnt.compare_exchange_weak(old_val, new_val));
    }
}

// 测试
int main() {
    std::thread t1(lock_free_count), t2(lock_free_count);
    t1.join(); t2.join();
    std::cout << "CAS 无锁计数器: " << cas_cnt << std::endl; // 200000
    return 0;
}

// --------------------------
// CAS 实现：安全更新共享变量
// 场景：任意线程安全值修改
// --------------------------
std::atomic<int> value{10};

void update_value(int target) {
    int old = value;
    // 只有当前值=old，才更新为target
    if (value.compare_exchange_weak(old, target)) {
        std::cout << "更新成功！\n";
    } else {
        std::cout << "值已被修改，更新失败！\n";
    }
}

// ===================== C++ RAII 自动锁（通用）=====================
template <typename Lock>
class ScopedLock {
private:
    Lock& lock_;
public:
    explicit ScopedLock(Lock& lock) : lock_(lock) { lock_.lock(); }
    ~ScopedLock() { lock_.unlock(); }
    // 禁用拷贝
    ScopedLock(const ScopedLock&) = delete;
    ScopedLock& operator=(const ScopedLock&) = delete;
};

// ===================== 测试代码 =====================
int counter = 0;
// 二选一测试：TasSpinLock 或 CasSpinLock
TasSpinLock spin_lock;
// CasSpinLock spin_lock;

// 线程工作函数
void work() {
    for (int i = 0; i < 100000; ++i) {
        ScopedLock<decltype(spin_lock)> lock(spin_lock); // 自动加锁/解锁
        counter++;
    }
}

int main() {
    // 创建两个线程竞争锁
    std::thread t1(work);
    std::thread t2(work);

    t1.join();
    t2.join();

    // 正确结果：200000
    std::cout << "最终计数: " << counter << std::endl;
    return 0;
}