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

目录

1.TAS和CAS介绍

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

3.CAS 核心使用场景

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

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

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

4.测试代码

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 原生的最简单原子指令，只能实现基础互斥自旋锁，优点是代码极简，缺点是多核性能差。

#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.高性能自旋锁（多核首选）

// -------------------------- // 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 可以实现完全无锁的并发操作，比自旋锁更快：

// -------------------------- // 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.线程安全变量更新（通用值替换）

// -------------------------- // 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.测试代码

// ===================== 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对比