一、竞争条件的本质与危害

当多个线程同时访问共享资源且至少有一个线程进行写操作时，竞争条件（Race Condition）就会悄然出现。这种看似随机的错误实际上遵循着特定的发生规律：

cpp
// 典型竞争条件示例
int sharedValue = 0;

void increment() {
for(int i=0; i<100000; ++i) {
sharedValue++; // 非原子操作
}
}

当两个线程并行执行increment()时，最终的sharedValue几乎不会达到预期的200000。这是因为sharedValue++在机器指令层面实际包含：
1. 寄存器加载变量值
2. 寄存器值+1
3. 写回内存

这三步操作可能被其他线程打断，导致最终结果丢失部分更新。

二、内存屏障：硬件层面的同步基石

内存屏障（Memory Barrier）是CPU提供的底层同步指令，主要解决两个核心问题：
1. 指令重排序：现代处理器会优化指令执行顺序
2. 可见性：确保写操作对其他线程可见

cpp
// 内存屏障使用示例
std::atomic flag(0);
int data = 0;

// 线程A
data = 42;
flag.store(1, std::memoryorderrelease); // 释放屏障

// 线程B
while(flag.load(std::memoryorderacquire) != 1); // 获取屏障
std::cout << data; // 保证看到42

C++11提供了六种内存序：
- memory_order_relaxed：仅保证原子性
- memory_order_consume：依赖关系可见
- memory_order_acquire：防止后续读操作重排到屏障前
- memory_order_release：防止前面写操作重排到屏障后
- memory_order_acq_rel：acquire+release组合
- memory_order_seq_cst：全序约束（默认模式）

三、五大同步原语实战解析

1. 互斥锁（Mutex）

cpp std::mutex mtx; void safeIncrement() { std::lock_guard<std::mutex> lock(mtx); sharedValue++; // 临界区操作 }

死锁预防技巧：
- 遵循固定顺序上锁
- 使用std::scoped_lock（C++17）
- 设置超时机制（try_lock_for）

2. 原子操作（Atomic）

cpp std::atomic<int> counter(0); counter.fetch_add(1, std::memory_order_relaxed);

原子类型支持：
- 算术运算（fetchadd/sub...） - 位运算（fetchand/or/xor）
- 比较交换（compareexchangestrong/weak）

3. 条件变量（Condition Variable）

cpp
std::condition_variable cv;
std::mutex mtx;
bool ready = false;

// 生产者
{
std::lockguard lk(mtx); ready = true; } cv.notifyone();

// 消费者
std::unique_lock lk(mtx);
cv.wait(lk, []{return ready;});

虚假唤醒处理：必须使用谓词参数的wait版本

4. 读写锁（Shared Mutex）

cpp
std::shared_mutex smtx;

// 写线程
{
std::unique_lock lock(smtx);
// 写入操作
}

// 读线程
{
std::shared_lock lock(smtx);
// 读取操作
}

5. 信号量（Semaphore）

C++20引入的轻量级同步工具：cpp
std::counting_semaphore<10> sem(0);

// 发布者
sem.release();

// 接收者
sem.acquire();

四、性能优化与陷阱规避

1. 锁粒度优化：

   
   
   
   • 缩小临界区范围
   • 使用读者-写者锁
   • 考虑无锁设计

2. 缓存行效应：
   cpp struct alignas(64) CacheLineAligned { std::atomic<int> data; }; // 避免伪共享

3. 静态初始化陷阱：
   cpp // 保证线程安全的单例 static Singleton& instance() { static Singleton inst; return inst; }

五、现代C++并发最佳实践

1. 优先使用std::async替代原始线程
2. 线程间通信建议使用std::promise/std::future
3. 复杂场景考虑任务并行（TBB）或GPU加速（CUDA）
4. 使用ThreadSanitizer等工具检测数据竞争

通过合理组合这些同步机制，开发者可以构建出既高效又安全的并发系统。记住：多线程编程的核心不是消灭锁，而是理解共享状态的管理艺术。