C++如何在C++内存模型中避免竞态条件

P粉602998670

发布时间：2025-09-18 08:16:01

576人浏览过

来源于php中文网

原创

C++内存模型中的竞态条件源于多线程执行顺序的不确定性，即使无数据竞争，指令重排也可能导致逻辑错误；为避免此问题，应使用互斥锁保护临界区、原子操作保证单一变量的原子性，并通过内存序（如release-acquire）建立操作间的“先行发生”关系，确保正确同步。

c++如何在c++内存模型中避免竞态条件

在C++内存模型中避免竞态条件，核心在于理解并正确应用同步原语与内存序。这不单单是代码层面的技术挑战，更是一种思维模式的转变，要求我们对多线程环境下的数据访问和可见性有深刻的洞察。老实说，这领域即便对经验丰富的开发者来说，也常常是让人挠头的问题。

解决方案

要有效避免竞态条件，我们首先要明确哪些数据会被多个线程同时访问，并对这些共享数据进行严格的保护。最直接且常用的方法是使用互斥锁（

std::mutex

）来保护临界区，确保在任何给定时刻只有一个线程能够访问特定的共享资源。当一个线程需要访问共享数据时，它会尝试锁定互斥锁；如果锁已经被其他线程持有，当前线程就会阻塞，直到锁被释放。这种方式虽然简单有效，但过度使用或粒度过粗可能导致性能瓶颈。

更进一步，对于一些简单的、原子性的操作，例如对单个整数的增减，我们可以利用C++11引入的原子操作（

std::atomic

）。这些操作在硬件层面保证了不可中断性，避免了锁的开销，从而在某些场景下提供了更高的性能。原子操作的强大之处在于，它们不仅保证了操作本身的原子性，还能通过内存序（memory order）机制，影响其他线程对内存操作的可见性，这正是C++内存模型的核心所在。

此外，条件变量（

std::condition_variable

）在线程间协调复杂逻辑时不可或缺，例如一个线程需要等待另一个线程完成某个任务或满足某个条件才能继续执行。而读写锁（

std::shared_mutex

，C++17）则允许在读多写少的场景下，多个线程同时读取共享数据，但在写入时依然保持独占，这能显著提升并发性能。

立即学习“C++免费学习笔记（深入）”；

C++内存模型中的竞态条件究竟是什么？为什么它如此难以捉摸？

在我看来，C++内存模型中的竞态条件，远比我们直观理解的“两个线程同时改一个变量”要复杂得多。它不仅仅是数据竞争（data race），即多个线程同时访问同一个内存位置，并且至少有一个是写入操作，且没有同步措施。数据竞争会导致未定义行为，这是C++标准明确禁止的。但竞态条件更广义，它指的是程序的行为依赖于不可预测的线程执行时序，即使没有数据竞争，也可能因为操作顺序的不可控性导致非预期的结果。

之所以难以捉摸，原因在于现代CPU和编译器为了性能优化，会对指令进行重排（reordering）。比如，你代码里写的是A操作然后B操作，但在实际执行时，CPU或编译器可能为了提高效率，把B先执行了。在单线程环境下这没问题，因为它们会保证“as-if”规则，即最终结果和顺序执行一样。但在多线程环境下，这种重排就可能让其他线程看到一个“乱序”的世界。

举个例子：

int x = 0;
bool ready = false;

// 线程A
void producer() {
    x = 42;         // (1)
    ready = true;   // (2)
}

// 线程B
void consumer() {
    while (!ready); // (3)
    // 此时x的值是多少？ (4)
    // cout << x << endl;
}

这里，如果

x = 42

和

ready = true

被重排，线程B可能在

ready

为

true

时，却看到了

仍然是

。这就是一个典型的竞态条件，尽管这里没有直接的数据竞争（

和

ready

是不同的变量），但程序的逻辑依赖于这两个操作的顺序。我们必须使用内存序来强制这些操作的顺序。

如何选择合适的同步原语：从互斥锁到原子操作

选择正确的同步原语，就像为不同的任务挑选合适的工具。没有万能的解决方案，只有最适合特定场景的。

```
std::mutex
```
(互斥锁)：这是最通用、最直接的保护共享资源的手段。当你有一段复杂的临界区，里面涉及多个共享变量的读写，或者需要执行一些非原子性的复合操作时，
```
std::mutex
```
是首选。它的优点是简单易用，能够保护任意复杂的代码段。缺点是开销相对较大，并且可能引入死锁（deadlock）的风险，如果锁的粒度过粗，还会限制并发度。
```
std::mutex mtx;
int shared_data = 0;

void increment_data() {
    std::lock_guard lock(mtx); // RAII风格的锁
    shared_data++;
    // 更多复杂操作...
}
```
```
std::atomic
```
(原子操作)：当你的操作仅仅是对一个单一变量进行简单的读、写、增、减、比较交换等操作时，
```
std::atomic
```
是更高效的选择。它避免了操作系统级别的锁开销，直接利用CPU的原子指令。例如，一个计数器，或者一个只通过布尔标志来同步的简单状态。
```
std::atomic counter{0};

void increment_counter() {
    counter.fetch_add(1); // 原子地增加1
}
```
使用
```
std::atomic
```
的关键在于理解其提供的内存序，这决定了操作的可见性。如果只是简单的计数，
```
std::memory_order_relaxed
```
可能就足够了，但如果涉及到跨线程的因果关系，就需要更强的内存序。
```
std::shared_mutex
```
(读写锁，C++17)：如果你的共享资源是“读多写少”的，那么
```
std::mutex
```
会限制并发读的性能。
```
std::shared_mutex
```
允许任意数量的线程同时获取共享锁（读锁），但在有线程获取独占锁（写锁）时，其他读写线程都会被阻塞。这大大提高了读操作的并发性。

Replit Ghostwrite
一种基于 ML 的工具，可提供代码完成、生成、转换和编辑器内搜索功能。

下载
```
std::shared_mutex rw_mtx;
int shared_value = 0;

void read_value() {
    std::shared_lock lock(rw_mtx); // 读锁
    // 读取 shared_value
}

void write_value(int new_val) {
    std::unique_lock lock(rw_mtx); // 写锁
    shared_value = new_val;
}
```

std::condition_variable

(条件变量)：当一个线程需要等待某个条件满足才能继续执行，而这个条件可能由另一个线程改变时，条件变量就派上用场了。它通常与

std::mutex

配合使用，避免了忙等待（busy-waiting），提高了效率。

std::mutex mtx_cv;
std::condition_variable cv;
bool data_ready = false;

void producer_cv() {
    std::lock_guard lock(mtx_cv);
    // 准备数据...
    data_ready = true;
    cv.notify_one(); // 通知一个等待线程
}

void consumer_cv() {
    std::unique_lock lock(mtx_cv);
    cv.wait(lock, []{ return data_ready; }); // 等待条件满足
    // 处理数据...
}

在我看来，选择同步原语更像是一种权衡：简单性与性能、并发性与复杂性。通常，从

std::mutex

开始，如果遇到性能瓶颈，再考虑

std::atomic

或

std::shared_mutex

，并深入研究内存序。

内存序（Memory Order）在无锁编程中的关键作用与实践

内存序是C++内存模型中最复杂也最强大的部分，它定义了不同线程如何观察到彼此的内存操作顺序。在无锁编程中，如果只是简单地使用

std::atomic

而不指定内存序，默认是

std::memory_order_seq_cst

（顺序一致性），这是最强也是开销最大的内存序。但很多时候，我们不需要那么强的保证，或者说，我们可以通过更精细的控制来获得更好的性能。

理解内存序的关键在于“同步关系”（synchronizes-with）和“先行发生”（happens-before）原则。一个操作A“先行发生”于操作B，意味着操作A的效果对操作B可见。内存序就是用来建立这些“先行发生”关系的。

主要的内存序包括：

```
std::memory_order_relaxed
```
：最弱的内存序。它只保证原子操作本身的原子性，不提供任何跨线程的同步或排序保证。这意味着编译器和CPU可以随意重排这个原子操作与其他非原子操作，甚至与其他
```
relaxed
```
原子操作。适用于那些不依赖于其他线程操作结果的计数器等场景。
```
std::atomic counter_relaxed{0};
void func_relaxed() {
    counter_relaxed.fetch_add(1, std::memory_order_relaxed);
}
```
这里，
```
fetch_add
```
是原子的，但它和
```
func_relaxed
```
函数内部的其他操作，以及其他线程的
```
relaxed
```
操作之间，没有任何顺序保证。
```
std::memory_order_release
```
：释放语义。它保证当前线程在
```
release
```
操作之前的所有写操作，对其他线程的
```
acquire
```
操作都是可见的。可以理解为，它“释放”了之前的所有内存修改，让它们对其他线程可见。

std::memory_order_acquire

：获取语义。它保证当前线程在

acquire

操作之后的所有读操作，能够看到其他线程在

release

操作之前的所有写操作。可以理解为，它“获取”了其他线程释放的内存修改。

release-acquire

配对是实现生产者-消费者模型的核心。

std::atomic ptr{nullptr};
std::atomic data_ready{false};

void producer_mo() {
    int* data = new int(42);
    ptr.store(data, std::memory_order_release); // 释放语义，保证data的写入在ptr写入前完成并可见
    data_ready.store(true, std::memory_order_release);
}

void consumer_mo() {
    while (!data_ready.load(std::memory_order_acquire)); // 获取语义，保证看到data_ready为true时，也能看到ptr的写入
    int* data = ptr.load(std::memory_order_acquire);
    // 使用data...
}

在这个例子中，

ptr.store

和

data_ready.store

的

release

语义确保了

new int(42)

这个操作在

ptr

和

data_ready

写入之前完成，并且对

consumer_mo

中的

acquire

操作可见。

```
std::memory_order_acq_rel
```
：既有获取语义又有释放语义。常用于
```
read-modify-write
```
（RMW）操作，如
```
fetch_add
```
，它既要读取旧值（获取），又要写入新值（释放）。
```
std::memory_order_seq_cst
```
：顺序一致性。这是最强的内存序，也是默认的。它保证所有
```
seq_cst
```
操作都遵循一个全局的、唯一的总顺序。这意味着即使在不同线程中，所有的
```
seq_cst
```
操作看起来都像是按一个特定的顺序执行的。虽然最安全，但开销也最大，因为它通常需要内存屏障来强制所有CPU核心遵守这个全局顺序。