面试题：C++ 多线程下的内存模型一致性问题

C++多线程编程中内存模型一致性面临的挑战

缓存一致性问题：现代处理器为提高性能，每个核心都有自己的缓存。当多个线程在不同核心上操作共享数据时，可能会出现某个核心缓存中的数据与其他核心缓存以及主内存中的数据不一致的情况。例如，线程A在核心1上修改了共享变量x，核心1的缓存更新了，但核心2的缓存中x的值还未更新，此时线程B在核心2上读取x，可能得到旧值。
指令重排序：编译器和处理器为优化性能，可能会对指令进行重排序。在单线程环境下，指令重排序不会影响程序最终结果，但在多线程环境中，可能导致数据竞争和不一致。比如，在一个线程中先写变量a，再写变量b，在另一个线程中先读b，再读a，若发生指令重排序，可能先读到b的新值，后读到a的旧值，破坏程序逻辑。

C++11内存序（memory order）的概念

C++11引入内存序来控制原子操作的内存可见性和顺序。内存序定义了原子操作之间的同步关系，分为以下几种：

std::memory_order_relaxed：最宽松的内存序，仅保证原子操作的原子性，不提供任何同步或顺序保证。适用于只需要保证原子性，对内存同步顺序要求不高的场景，如简单的计数器。
std::memory_order_release：此内存序用于写操作。标记为该内存序的写操作，在其之前的所有内存操作对其他线程可见，直到有线程以std::memory_order_acquire或更强的内存序读取这个原子变量。
std::memory_order_acquire：用于读操作。以该内存序读取原子变量时，保证后续的内存操作不会被重排序到该读操作之前，且保证在该读操作之前，其他线程以std::memory_order_release内存序对该原子变量的写操作对本线程可见。
std::memory_order_acq_rel：同时具有std::memory_order_acquire和std::memory_order_release的语义，用于读 - 改 - 写操作。
std::memory_order_seq_cst：顺序一致性内存序，是最严格的内存序。所有标记为该内存序的原子操作，在所有线程中都以一种全局一致的顺序执行，就好像所有线程都按顺序执行这些原子操作一样。

使用std::atomic和memory_order参数确保数据一致性和避免竞态条件

std::atomic：C++11引入的原子类型模板，保证对其成员的操作是原子的，无需额外的锁机制。例如std::atomic<int> counter;，对counter的操作如counter++;是原子的。
结合memory_order参数：

#include <atomic>
#include <thread>
#include <iostream>

std::atomic<int> data(0);
std::atomic<bool> ready(false);

void producer() {
    data.store(42, std::memory_order_release);
    ready.store(true, std::memory_order_release);
}

void consumer() {
    while (!ready.load(std::memory_order_acquire));
    std::cout << "Data: " << data.load(std::memory_order_acquire) << std::endl;
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

在上述代码中，producer线程先使用std::memory_order_release内存序存储数据和设置ready标志。consumer线程在读取数据前，先以std::memory_order_acquire内存序等待ready标志为真，然后再以同样内存序读取数据，确保能读到producer线程存储的最新数据，避免竞态条件。

复杂场景下的多线程内存同步问题及解决方案

问题场景：假设有多个线程对共享的矩阵进行操作，一些线程负责更新矩阵元素，另一些线程负责计算矩阵的某些统计信息（如总和）。在更新矩阵元素时，可能会出现多个线程同时修改同一元素的情况，而且计算统计信息的线程需要确保读取到最新的矩阵状态。 解决方案：

#include <atomic>
#include <thread>
#include <vector>
#include <iostream>

const int rows = 10;
const int cols = 10;
std::vector<std::vector<std::atomic<int>>> matrix(rows, std::vector<std::atomic<int>>(cols, 0));

void updateElement(int i, int j, int value) {
    matrix[i][j].store(value, std::memory_order_release);
}

int calculateSum() {
    int sum = 0;
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            sum += matrix[i][j].load(std::memory_order_acquire);
        }
    }
    return sum;
}

int main() {
    std::thread updater1(updateElement, 0, 0, 1);
    std::thread updater2(updateElement, 1, 1, 2);
    std::thread sumCalculator(calculateSum);

    updater1.join();
    updater2.join();
    sumCalculator.join();

    std::cout << "Sum of matrix: " << calculateSum() << std::endl;
    return 0;
}

在这个方案中，使用std::atomic<int>来存储矩阵元素，更新元素的线程使用std::memory_order_release内存序，计算总和的线程使用std::memory_order_acquire内存序。这样可以确保更新操作对计算总和的线程可见，避免因内存不一致导致的计算错误，有效解决多线程内存同步问题。

星途面试题库

面试题：C++ 多线程下的内存模型一致性问题

知识考点

面试题答案

C++多线程编程中内存模型一致性面临的挑战

C++11内存序（memory order）的概念

使用std::atomic和memory_order参数确保数据一致性和避免竞态条件

复杂场景下的多线程内存同步问题及解决方案