C++中TAS和CAS实现自旋锁

1.TAS和CAS介绍

[2.TAS 使用场景：极简自旋锁](#2.TAS 使用场景：极简自旋锁)

[3.CAS 核心使用场景](#3.CAS 核心使用场景)

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

[3.2.无锁线程安全计数器（不用锁，纯 CAS）](#3.2.无锁线程安全计数器（不用锁，纯 CAS）)

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

4.测试代码

[5.TAS vs CAS对比](#5.TAS vs CAS对比)

1.TAS和CAS介绍

它们是CPU 硬件提供的两种最基础的原子读 - 改 - 写（RMW）指令，专门用来解决多线程并发竞争问题，是所有锁、无锁结构的底层基石。

TAS = Test-And-Set 「测试并设置」

读取内存里的旧值
强制把这个内存写成 1（true）
返回刚才读到的旧值

核心特征：一定会写，不管原来是什么

CAS = Compare-And-Swap 「比较并交换」

拿内存当前值和你给的期望值对比
如果相等，才把内存改成新值
如果不等，什么都不做
返回是否修改成功

核心特征：条件写入，不满足就不碰内存

总结：

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

两者都是原子操作，CPU 保证整个过程一步完成，不会被其他线程打断。

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

TAS 是 CPU 原生的最简单原子指令 ，只能实现基础互斥自旋锁，优点是代码极简，缺点是多核性能差。

cpp 复制代码

#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;
}

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

❌ 不适合：多核高竞争（缓存颠簸严重）

3.CAS 核心使用场景

CAS 是现代并发编程的基石 ，支持条件写入，自旋时不修改共享变量，多核性能远超 TAS。

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

cpp 复制代码

// --------------------------
// 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);
    }
};

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

CAS 可以实现完全无锁的并发操作，比自旋锁更快：

cpp 复制代码

// --------------------------
// 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;
}

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

cpp 复制代码

// --------------------------
// 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";
    }
}

4.测试代码

cpp 复制代码

// ===================== 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;
}

5.TAS vs CAS对比

特性	TAS 自旋锁	CAS 自旋锁
原子操作	`atomic_exchange`（强制写）	`atomic_cmpxchg`（条件写）
自旋行为	每次循环都修改锁变量	自旋时只读，不修改
缓存性能	差（多核缓存颠簸、总线流量大）	优（缓存一致性友好）
性能场景	单核 / 低竞争尚可，多核高竞争拉胯	多核 / 高竞争首选，现代标准实现
灵活性	仅能做简单自旋锁	可实现无锁队列、公平锁、futex 等