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

1. TAS和CAS介绍

在多线程并发编程的世界里，CPU硬件提供的两种最基础的原子读-改-写（RMW）指令，绝对是所有锁机制和无锁数据结构的底层基石。如果没有它们，现代高并发应用几乎寸步难行。那么，这两位“基石选手”——TAS和CAS，究竟是何方神圣？

TAS，全称 Test-And-Set，即“测试并设置”。它的操作模式非常“霸道”：

• 先读取内存里的旧值；
• 然后强制把这个内存地址写成 1（或者 true）；
• 最后返回刚才读到的那个旧值。

其核心特征在于：一定会写，不管原来的值是什么。它就像一个“先占再说”的莽汉。

CAS，全称 Compare-And-Swap，即“比较并交换”。它的方式则优雅得多：

• 拿内存当前值和给定的期望值进行对比；
• 如果两者相等，才把内存修改为新值；
• 如果不等，则什么也不做；
• 最后返回是否修改成功。

其核心特征在于：条件写入，不满足条件就绝不碰内存。

用一个简单的类比来总结：

• TAS：先写为“占用”，再告诉你之前是不是“空闲”。
• CAS：先看是不是“空闲”，是才“占用”，不是就直接放弃。

无论哪种方式，它们都是原子操作。这意味着CPU会保证整个过程一步完成，绝不会被其他线程打断。

2. TAS使用场景：极简自旋锁

TAS是CPU原生支持的最简单的原子指令，它的唯一本领就是实现最基础的互斥自旋锁。优点是代码极简，但缺点也很明显——在多核环境下，性能相当拉胯。

#include 
#include 
#include 

//intel指令
#include 
//_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 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;
}

✅ 适合：简单互斥、低并发、代码极简

❌ 不适合：多核高竞争（容易引发严重的缓存颠簸）

3. CAS核心使用场景

如果说TAS是入门级的莽汉，那CAS就是现代并发编程的真正基石。它支持条件写入，自旋时不会反复修改共享变量，在多核性能上远超TAS。

3.1. 高性能自旋锁（多核首选）

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

3.2. 无锁线程安全计数器（不用锁，纯CAS）

CAS的威力不止于做锁，它还能实现完全无锁的并发操作，比自旋锁更胜一筹：

// --------------------------
// CAS 实现：无锁原子计数器
// 场景：高并发计数（无锁、高性能）
// --------------------------
std::atomic 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;
}

3.3. 线程安全变量更新（通用值替换）

// --------------------------
// CAS 实现：安全更新共享变量
// 场景：任意线程安全值修改
// --------------------------
std::atomic 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";
    }
}

4. 测试代码

// ===================== C++ RAII 自动锁（通用）=====================
template 
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 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;
}

5. TAS vs CAS 对比