引言

在多线程编程中，多个线程同时访问和修改共享变量时，容易引发竞态条件（Race Condition）和数据不一致问题。C++提供了多种同步机制来确保线程安全。本文将通过具体示例，解析多线程同步的核心要点和最佳实践。

1. 问题根源：竞态条件

当多个线程对共享变量的读写操作未加控制时，最终结果可能取决于线程执行顺序。例如：

int counter = 0;
void increment() { counter++; }  // 非线程安全

若多个线程同时调用increment()，最终counter的值可能小于预期。

2. 同步机制：关键解决方案

2.1 互斥锁（Mutex）

核心思想：通过互斥锁确保同一时间只有一个线程访问临界区。 实现方式：

#include <mutex>
std::mutex mtx;

void safe_increment() {
    mtx.lock();   // 加锁
    counter++;    // 临界区
    mtx.unlock(); // 解锁
}

关键要点： - RAII封装：使用std::lock_guard或std::unique_lock自动管理锁，避免忘记解锁。 - 性能开销：频繁加锁/解锁可能成为瓶颈，需合理缩小临界区范围。

2.2 原子操作（Atomic Operations）

核心思想：通过原子类型保证操作的不可分割性。 适用场景：简单变量（如int、bool）的读-改-写操作。 实现示例：

#include <atomic>
std::atomic<int> atomic_counter = 0;

void atomic_increment() {
    atomic_counter++; // 原子操作
}

关键要点：

- 内存顺序：通过std::memory_order控制指令重排序，默认seq_cst（顺序一致性）。

- 局限性：无法保护复杂操作（如多个变量联动修改）。

2.3 条件变量（Condition Variable）

核心思想：线程间通过条件变量实现等待-通知机制。

典型场景：生产者-消费者模型。

实现示例：

#include <condition_variable>
std::condition_variable cv;
std::mutex mtx;
bool ready = false;

void consumer() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; }); // 等待条件满足
    // 消费数据
}

void producer() {
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_one(); // 通知消费者
}

关键要点：

- 谓词检查：使用带谓词的wait()避免虚假唤醒。

- 配合互斥锁：条件变量需与互斥锁结合使用。

2.4 信号量（Semaphore）

核心思想：通过计数器控制线程访问资源的数量。

C++20实现：

#include <semaphore>
std::counting_semaphore<5> sem(5); // 最多5个线程同时访问

void worker() {
    sem.acquire(); // 占用一个许可
    // 访问共享资源
    sem.release(); // 释放许可
}

关键要点：

- 灵活控制：适用于有限资源的并发访问场景。

3. 选择同步机制的原则

1. 最小化同步范围：仅保护必要的代码段。
2. 性能优先：优先使用原子操作（无锁），其次互斥锁，最后条件变量。
3. 避免死锁：按顺序加锁、限时等待（try_lock_for）。

4. 总结：关键要点速查表

结语

多线程同步是C++编程的难点之一。

通过合理选择同步机制、遵循最佳实践（如RAII、最小化临界区），可有效避免竞态条件，提升程序的健壮性和性能。