C++11多线程内存模型：从入门到精通

oioihoii2025-06-19 10:20

文章目录

    • 一、引言
    • 二、C++11多线程内存模型基础
      • [2.1 什么是内存模型](#2.1 什么是内存模型)
      • [2.2 为什么需要内存模型](#2.2 为什么需要内存模型)
      • [2.3 C++11之前的多线程编程困境](#2.3 C++11之前的多线程编程困境)
      • [2.4 C++11内存模型的重要性](#2.4 C++11内存模型的重要性)
    • 三、基础概念
      • [3.1 同步点](#3.1 同步点)
      • [3.2 同步关系（synchronized - with）](#3.2 同步关系（synchronized - with）)
      • [3.3 先于发生关系（happens - before）](#3.3 先于发生关系（happens - before）)
      • [3.4 顺序关系（sequenced - before）](#3.4 顺序关系（sequenced - before）)
    • 四、原子操作
      • [4.1 原子操作的定义](#4.1 原子操作的定义)
      • [4.2 C++11中的原子类型](#4.2 C++11中的原子类型)
      • [4.3 原子操作示例](#4.3 原子操作示例)
    • 五、内存顺序
      • [5.1 为什么需要内存顺序](#5.1 为什么需要内存顺序)
      • [5.2 C++11定义的6种内存顺序](#5.2 C++11定义的6种内存顺序)
      • [5.3 内存顺序的选择技巧](#5.3 内存顺序的选择技巧)
    • 六、内存栅栏
      • [6.1 内存栅栏的作用](#6.1 内存栅栏的作用)
      • [6.2 内存栅栏的类型](#6.2 内存栅栏的类型)
      • [6.3 C++中的内存栅栏实现](#6.3 C++中的内存栅栏实现)
      • [6.4 内存栅栏使用示例](#6.4 内存栅栏使用示例)
    • 七、应用场景
      • [7.1 计数器和标志位](#7.1 计数器和标志位)
      • [7.2 生产者 - 消费者模型](#7.2 生产者 - 消费者模型)
      • [7.3 无锁数据结构](#7.3 无锁数据结构)
    • 八、总结

一、引言

在当今的软件开发领域，多线程编程已经成为了提升程序性能和响应能力的重要手段。然而，多线程环境下的内存访问和同步问题却给开发者带来了诸多挑战。C++11标准的出现，为多线程编程带来了重大变革，其中内存模型的改进尤为关键。本文将带领小白们从入门到精通，深入了解C++11多线程内存模型。

二、C++11多线程内存模型基础

2.1 什么是内存模型

内存模型可以理解为存储一致性模型，主要是从行为方面来看多个线程对同一个对象同时（读写）操作时所做的约束。它定义了线程间数据共享和同步的基本规则，包括顺序一致性、原子操作、内存屏障和数据依赖性等关键概念。

2.2 为什么需要内存模型

在多核处理器中，每个线程可能运行在不同的核心上，每个核心有自己的缓存。编译器和处理器为了提高性能，可能会对指令进行重排序，导致可见性问题和顺序问题。例如，一个线程修改的数据可能不会立即被其他线程看到，线程观察到的内存操作顺序可能与实际执行顺序不同。内存模型通过约束编译器和处理器的重排序行为，确保多线程间共享数据的正确性。

2.3 C++11之前的多线程编程困境

在C++11标准发布之前，C++语言对于多线程编程的支持相对薄弱，开发者往往需要借助第三方库或平台特定的API来实现多线程功能。这不仅增加了代码的复杂性和维护成本，还难以保证程序在不同平台上的一致性和可移植性。而且，由于缺乏统一的内存模型规范，程序容易出现数据竞争和其他多线程相关的问题，这些问题往往难以调试和修复。

2.4 C++11内存模型的重要性

C++11的出现，为多线程编程带来了重大变革。它引入了一系列新的特性和工具，其中内存模型的改进尤为关键。C++11内存模型为多线程环境下的内存访问和同步提供了清晰、统一的规则和语义，使得开发者能够更准确地控制线程之间的交互，避免数据竞争和其他多线程相关的问题。

三、基础概念

3.1 同步点

对于一个原子类型变量a，如果a在线程1中进行store（写）操作，在线程2中进行load（读）操作，则线程1的store和线程2的load构成原子变量a的一对同步点，其中的store操作和load操作就分别是一个同步点。同步点具有三个条件：必须是一对原子变量操作中的一个，且一个操作是store，另一个操作是load；这两个操作必须针对同一个原子变量；这两个操作必须分别在两个线程中。

3.2 同步关系（synchronized - with）

对于一对同步点来说，当写操作写入一个值x后，另一个同步点的读操作在某一时刻读到了这个变量的值x，则此时就认为这两个同步点之间发生了同步关系。同步关系具有两方面含义：针对的是一对同步点之间的一种状态的描述；只有当读取的值是另一个同步点写入的值的时候，这两个同步点之间才发生同步。

3.3 先于发生关系（happens - before）

当线程1中的操作A先执行，而线程2中的操作B后执行时，A就happens - before B。happens - before是用来表示两个线程中两个操作被执行的先后顺序的一种描述。happens - before有三个特点：可传递性。如果A happens - before B，B happens - before C，则有A happens - before C；当store操作A与load操作B发生同步时，则A happens - before B；happens - before一般用于描述分别位于两个线程中的操作之间的顺序。

3.4 顺序关系（sequenced - before）

如果在单个线程内操作A发生在操作B之前，则表示为A sequenced - before B。这个关系是描述单个线程内两个操作之前的先后执行顺序的，与happens - before是相对的。此外，sequenced - before也具有可传递性，并且sequenced - before与happences - before之间也具有可传递性：如果线程1中操作A sequenced - before操作B，而操作B happences - before线程2中的操作C，操作C sequenced - before线程2中的操作D，则有操作A happences - before操作D。

四、原子操作

4.1 原子操作的定义

原子操作是在多线程程序中"最小的且不可并行化的"操作，意味着多个线程访问同一个资源时，有且仅有一个线程能对资源进行操作。通常情况下原子操作可以通过互斥的访问方式来保证，如Linux下的互斥锁（mutex）和Windows下的临界区（Critical Section）等。

4.2 C++11中的原子类型

C++11标准引入了std::atomic类模板，提供了对基本数据类型的原子操作支持。常见的原子类型有：

原子类型名称 对应内置类型
atomic_bool bool
atomic_char atomic_char
atomic_char signed char signed char
atomic_uchar unsigned char
atomic_short short
atomic_ushort unsigned short
atomic_int int
atomic_uint unsigned int
atomic_long long
atomic_ulong unsigned long
atomic_llong long long
atomic_ullong unsigned long long
atomic_char16_t char16_t
atomic_char32_t char32_t
atomic_wchar_t wchar_t

4.3 原子操作示例

cpp 复制代码 
#include <atomic>
#include <thread>
#include <iostream>

std::atomic<int> atomic_int(0);

void increment() {
    for (int i = 0; i < 10000; ++i) {
        atomic_int.fetch_add(1, std::memory_order_relaxed);
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Final value: " << atomic_int.load() << std::endl;
    return 0;
}

在这个示例中，我们使用std::atomic定义了一个原子整数atomic_int，并初始化为0。fetch_add函数用于原子地增加atomic_int的值，并返回增加前atomic_int的值。std::memory_order_relaxed指定了内存顺序，表示不对操作的内存顺序做任何保证。

五、内存顺序

5.1 为什么需要内存顺序

在多核处理器中，编译器和处理器为了提高性能，可能会对指令进行重排序，导致可见性问题和顺序问题。内存顺序通过约束编译器和处理器的重排序行为，确保多线程间共享数据的正确性。

5.2 C++11定义的6种内存顺序

C++11定义了6种内存顺序，按约束强度从弱到强排列：

  1. memory_order_relaxed
    • 特性：仅保证原子性，不保证操作顺序和可见性。
    • 适用场景：不需要同步的计数器递增，例如统计次数。
    • 示例：
cpp 复制代码 
#include <atomic>
std::atomic<int> counter{0};
counter.fetch_add(1, std::memory_order_relaxed);
  1. memory_order_acquire
    • 特性：在读取操作时生效，确保当前线程中后续的所有读/写操作不会被重排序到该操作之前。
    • 适用场景：获取锁（Lock）或同步读取共享数据。
    • 示例：
cpp 复制代码 
#include <atomic>
std::atomic<bool> flag{ false };
// 线程A:
while (!flag.load(std::memory_order_acquire)); // 等待flag变为true
// 线程A后续的操作能看到线程B在release前的所有写入
// 线程B:
flag.store( true, std::memory_order_release); // 释放锁，写入对其他线程可见
  1. memory_order_release
    • 特性：在写入操作时生效，确保当前线程中之前的所有读/写操作不会被重排序到该操作之后。
    • 适用场景：释放锁或发布数据到其他线程。
  2. memory_order_acq_rel
    • 特性：同时具有acquire和release的语义，用于需要同时读写的操作（如compare_exchange_weak）。
    • 适用场景：适用于同时包含读取和写入的复杂同步场景。
  3. memory_order_consume
    • 特性：类似Acquire，但作用仅限当前线程（现代编译器中少用）。
    • 适用场景：C++特有的，程序可以说明哪些变量有依赖关系，从而只需要同步这些变量的内存。类似于memory_order_acquire，但是只对有依赖关系的内存。
  4. memory_order_seq_cst
    • 特性：严格顺序一致性（Sequential Consistency），所有线程看到的操作顺序一致。
    • 适用场景：需要严格数据同步的全局场景。
    • 示例：
cpp 复制代码 
#include <atomic>
#include <thread>
#include <iostream>
std::atomic<int> counter(0);
void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter.fetch_add(1, std::memory_order_seq_cst);
    }
}
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Final counter: " << counter.load(std::memory_order_seq_cst) << std::endl;
    return 0;
}

5.3 内存顺序的选择技巧

  • 无同步需求的操作：memory_order_relaxed适合独立计数器、标志等场景，减少同步开销。
  • 发布 - 获取同步场景：memory_order_release和memory_order_acquire配合使用适合生产者 - 消费者模式。
  • 复杂同步：包含读写操作的同步场景中，memory_order_acq_rel提供获取与释放的联合效果。
  • 高安全性同步：当全局同步一致性要求较高时，memory_order_seq_cst适合确保线程间数据一致。

六、内存栅栏

6.1 内存栅栏的作用

内存栅栏（Memory Barrier），之所以被称为"栅栏"，是因为它们在执行流中起到了隔离的作用，类似于现实生活中栅栏的功能，阻止某些事物通过。在计算机科学中，内存栅栏阻止指令重排越过这一"栅栏"，确保在栅栏一侧的操作（无论是读操作还是写操作）在逻辑上完全完成后，才能开始执行栅栏另一侧的操作。它可以防止编译器和处理器进行过度的指令重排，确保在并发环境下内存访问的正确性和一致性。

6.2 内存栅栏的类型

  • Load Barrier（加载栅栏）：确保所有在栅栏之前的读操作完成后，才能执行栅栏之后的读操作。
  • Store Barrier（存储栅栏）：确保所有在栅栏之前的写操作完成后，才能执行栅栏之后的写操作。
  • Full Barrier（全栅栏）：结合加载栅栏和存储栅栏的功能，确保所有在栅栏之前的读写操作完成后，才能执行栅栏之后的读写操作。

6.3 C++中的内存栅栏实现

C++11标准引入了原子操作和内存模型的概念，其中就包括对内存栅栏的支持。C++提供的内存栅栏是通过原子操作库中的内存顺序参数来实现的：

  • std::memory_order_relaxed：无同步或顺序制约。
  • std::memory_order_acquire：本线程中，所有后续的读操作都必须在本原子操作完成后执行。
  • std::memory_order_release：本线程中，所有之前的写操作完成后才能执行本原子操作。
  • std::memory_order_acq_rel：同时具有acquire和release的效果。
  • std::memory_order_consume：本线程中，所有后续的有关本原子操作，必须在本原子操作完成后执行。
  • std::memory_order_seq_cst：全栅栏，提供顺序一致的内存顺序。

6.4 内存栅栏使用示例

cpp 复制代码 
#include <atomic>
#include <mutex>
class Singleton {
public:
    static Singleton* getInstance() {
        Singleton* tmp = _instance.load(std::memory_order_relaxed);
        std::atomic_thread_fence(std::memory_order_acquire);
        if (tmp == nullptr) {
            std::lock_guard<std::mutex> lock(_mutex);
            tmp = _instance.load(std::memory_order_relaxed);
            if (tmp == nullptr) {
                tmp = new Singleton();
                std::atomic_thread_fence(std::memory_order_release);
                _instance.store(tmp, std::memory_order_relaxed);
            }
        }
        return tmp;
    }
private:
    Singleton() = default;
    ~Singleton() = default;
    static std::atomic<Singleton*> _instance;
    static std::mutex _mutex;
};
// 静态成员变量定义
std::atomic<Singleton*> Singleton::_instance(nullptr);
std::mutex Singleton::_mutex;

在这个示例中，我们使用std::atomic_thread_fence来确保在读取共享资源之前，所有先前的写操作（通常是其他线程写入的）都已经完成，并且读取操作不会在内存模型中被重排到栅栏之前。

七、应用场景

7.1 计数器和标志位

在多线程环境中，计数器和标志位是常见的同步工具。例如，一个线程可能需要等待另一个线程完成初始化操作，这时可以使用原子标志位来实现。

cpp 复制代码 
#include <atomic>
#include <thread>
#include <iostream>
std::atomic<bool> initialized(false);
void init_thread() {
    // 执行初始化操作
    initialized.store(true, std::memory_order_release);
}
void worker_thread() {
    while (!initialized.load(std::memory_order_acquire)) {
        std::this_thread::yield();
    }
    // 执行后续工作
    std::cout << "Initialization completed. Starting work..." << std::endl;
}
int main() {
    std::thread t1(init_thread);
    std::thread t2(worker_thread);
    t1.join();
    t2.join();
    return 0;
}

7.2 生产者 - 消费者模型

生产者 - 消费者模型是多线程编程中常见的场景，生产者通过memory_order_release发布数据，消费者通过memory_order_acquire读取，确保在发布数据后其他线程可以读取到正确的数据。

cpp 复制代码 
#include <atomic>
#include <thread>
#include <iostream>
std::atomic<int> data(0);
std::atomic<bool> ready(false);
void producer() {
    data.store(42, std::memory_order_relaxed); // 数据写入
    ready.store(true, std::memory_order_release); // 发布数据
}
void consumer() {
    while (!ready.load(std::memory_order_acquire)); // 获取数据
    std::cout << "Data: " << data.load(std::memory_order_relaxed) << std::endl;
}
int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

7.3 无锁数据结构

无锁数据结构是利用原子操作来实现的，它们不需要传统的锁机制来保证线程安全。例如，无锁栈、无锁队列等。

八、总结

C++11多线程内存模型为开发者提供了强大而灵活的工具，帮助我们在多线程环境下编写高效、安全的代码。通过深入理解原子操作、内存顺序和内存栅栏等概念，并合理运用它们，我们可以避免数据竞争和其他多线程相关的问题，提高程序的性能和可维护性。在实际开发中，我们需要根据具体的应用场景选择合适的内存顺序和同步机制，以达到最佳的效果。希望本文能够帮助小白们从入门到精通C++11多线程内存模型，在多线程编程的道路上越走越远。

热门推荐
01扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解02Coze扣子平台完整体验和实践（附国内和国际版对比）03KGG转MP3工具|非KGM文件|解密音频04AI Agent | Coze 插件使用指南：从功能解析到实操步骤05DeepSeek各版本说明与优缺点分析06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07字节跳动“扣子空间”AI智能体全解析08零代码入门 | Coze——让大模型接入自己的数据库09YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】10免费可用！最强AI数字人对口型神器：让照片开口说话唱歌，支持多人对口型+全身动作，1分钟学会！（附保姆级教程）