C++0x 内存模型和原子操作 （std:::atomic memory order等相关资料）

最新推荐文章于 2025-07-24 19:17:42 发布
转载 最新推荐文章于 2025-07-24 19:17:42 发布 · 1.3k 阅读 · 1

本文探讨了 C++11 中新增的并行编程特性，特别是 std::atomic 的使用及内存模型。文中详细介绍了不同 memory_order 的含义及其与内存屏障的关系，并通过示例展示了如何利用这些特性来确保数据的一致性和并发安全性。

并行编程的趋势不可阻挡啊，新的c++标准也加入了很多支持。内存模型和 std::atomic 的引入很值得学习吧，看facebook的开源c++库都用了很多c++ 11的特性了。 std::atomic 这些。


网上看到的最详细清楚的解释是，

C++ Concurrency in Action.pdf  一书的第五章

5 The C++ Memory Model and Operations on Atomic Types

对理解 c++ atomic 的memory order很有用处：


这个网页其实也是摘录的书的内容来的，

Memory Ordering for Atomic Operations in C++0x

http://www.developerfusion.com/article/138018/memory-ordering-for-atomic-operations-in


-c0x/


详细解析了 std::atomic 的不同存储模型 ，不同的值与memory order的关系：

有了Linux内核的里面内核屏障的概念的话，像下面这样里面比较容易吧。

typedef enum memory_order {

    memory_order_relaxed,   \\ 不指定内存屏障，所以内存操作执行时可能是乱序的。

    memory_order_acquire,   \\ 按照我理解就是插入一个 内存读屏障，保证之前的读操作先一步完成。清空自己cpu上"invalidate queues"  。

    memory_order_release,    \\ 按照我理解就是插入一个 内存写屏障，保证之前的写操作的顺序一定 。清空自己cpu上 的 “ store buffer"


在这之前完成

    memory_order_consume  类似memory_order_acquire，但只对依赖的指定数据起作用。

    memory_order_acq_rel,    \\ 同时插入读写两个屏障。  清空自己cpu上 的 “ store buffer" 和 "invalidate queues"  。

    memory_order_seq_cst    \\\默认的顺序模型。根据  http://en.cppreference.com/w/cpp/atomic/memory_order 这里的说明 （Total sequential ordering requires a full memory fence CPU instruction on all multi-core systems. This may become a performance bottleneck since it forces all memory accesses to propagate to every thread.）  这个会清空所有cpu上的读写同步消息队列 “ store buffer" 和 "invalidate queues"   （参考 http://hi.baidu.com/widebright/item/4e458d447c8bcfe11381daf0 ） 。  memory_order_acq_rel 应该是只清空自己cpu上 的 “ store buffer" 和 "invalidate queues"  。

        这个看上去和x86的lock指令前缀锁总线不太一样。不知道具体怎么实现的。

 

} memory_order;



书上的一个简单的例子。

-----------------------------------------------

#include <atomic>

#include <thread>

#include <assert.h>

 

std::atomic<bool> x,y;

std::atomic<int> z;

 

void write_x_then_y()

{

    x.store(true,std::memory_order_relaxed);             #1

    y.store(true,std::memory_order_release);             #2   //保证 第#1句的x写入在y的写入之前

}

 

void read_y_then_x()

{

    while(!y.load(std::memory_order_acquire));           #3     //保证 y的读取在 第#4句x的读取之前。所以  如果y看到修改后的值，肯定 第#4句看到的也是x的新的值了。

    if(x.load(std::memory_order_relaxed))                #4

        ++z;

}

 

int main()

{

    x=false;

    y=false;

    z=0;

    std::thread a(write_x_then_y);

    std::thread b(read_y_then_x);

    a.join();

    b.join();

    assert(z.load()!=0);                                 #5    //这个肯定通过的了。

}

-----------------------------------------------------------



也说道了内存屏障了

memory fences/barriers

c++ 里面除了上面那些为atomic类型指定明确的存储模型之外，也可以插入 指定的“内存读写屏障 


”的。



书中的其他章节也挺不粗哦的，

7

Designing Data Structures for

Concurrency II: Lock-free

Concurrent Data Structures



相面这个应该是c++的规范文档，解释了为什么要把c++的内存模型定义成这样子。

C++ Atomic Types and Operations

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html#DiscussOrder

Memory Model Rationales

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2176.html



想std：atomic 等特性，应该在行的gcc 和 vc11 里面都有支持了，

C++11 Features in Visual C++ 11

http://blogs.msdn.com/b/vcblog/archive/2011/09/12/10209291.aspx

Status of Experimental C++0x Support in GCC 4.6

http://gcc.gnu.org/gcc-4.6/cxx0x_status.html


像facebook的开源c++库好像这个std::atomic用的很多了，用来实现spinlock 。

可以去参考一下 https://github.com/facebook/folly/tree/master/folly


【转自：http://hi.baidu.com/widebright/item/ee9d66d2be106dba32db904e

GCC：内存模型：原子操作
mzhan017的博客
12-07 911
C++内存模型的设计，为并行环境，提供了可预期的结果，如同顺序执行一样。C标准也在参考此内存模型。主要有两个部分：a), 不再允许“引入数据竞争的“优化。意味着，不能在跨线程可见的数据上使用loads/stores。b), 新的原子类型。可以通过实现如下的标志位来通知编译器，实现C++11内存模型的竞态数据：这四个标志，可用用来限制优化器。在测试时，或者知识卓越的用户，可以打开或者关闭优化功能。对于普通用户，可用通过以下选项来实现关闭优化。
C++20 Atomic 原子 内存模型(二)
qq_42896106的博客
08-07 881
原子操作默认使用顺序一致性标志。
C++并发编程 -4.原子操作和内存模型
qq_45604814的博客
03-01 3179
原子操作是一类不可分割的操作，当这样操作在任意线程中进行一半的时候，你是不能查看的；它的状态要不就是完成，要不就是未完成。如果从对象中读取一个值的操作是原子的，并且对对象的所有修改也都是原子的话，那么加载操作要不就会检索对象初始化的值，要不就将值存在某一次修改中。说白了原子操作就是不可中断的操作，要么被执行要不不被执行。
C++并发编程（六）：内存顺序
qq_33215865的博客
03-03 3414
原子操作的内存顺行 有六个内存顺序选项可应用于对原子类型的操作：memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, 以及memory_order_seq_cst。除非你为特定的操作指定一个顺序选项，否则内存顺序选项对于所有原子类型...
C++ 并行编程之原子操作的内存顺序
OneGit
12-10 2574
C++ 并行编程之原子操作的内存顺序 1. C++原子操作的内存顺序概述 memory order主要有以下几种: memory_order_relaxed 只提供对单个atomic变量的原子读/写，不和前后语句有任何memory order的约束关系。 memory_order_consume 程序可以说明哪些变量有依赖关系，从而只需要同步这些变量的内存。 类似于memory_ord...
C++并发：原子操作、内存模型、内存屏障
wsq_zqfl的博客
11-27 1483
首先内存模型到底描述的是一个怎样的问题，对此问题网上可谓是群魔乱舞，说什么的都有，我们来看看维基百科对此问题的定义[16]：内存一致性模型描述的是程序在执行过程中内存操作正确性的问题。内存操作包括读操作和写操作，每一操作又可以用两个时间点界定：发出（Invoke）和响应（Response）。在假定没有流水线的情况下（即单个处理器内指令的执行是按顺序执行的），设系统内共有N个处理器，每个处理器可发出个内存操作（读或写），那么总共有：种可能的执行顺序。
C++11+ 原子操作 `std::atomic`，现代并发编程的核心
关注智践行，一起学机器人和AI技术
07-24 1014
重排是理解内存序的核心基础。在计算机系统中，程序指令的实际执行顺序与程序员在源代码中编写的顺序不一致的现象就是你写在代码里的语句顺序。比如你先写变量A = 10;，然后再写B = 20;。就是 CPU 实际执行这些指令的顺序，或者这些指令的效果（特别是内存读写）对其他 CPU 核心可见的顺序。而重排则是指执行顺序没有严格按照程序代码顺序进行。重排不是错误，也不是随意的行为。它是现代计算机系统为了追求极致性能而进行的一系列复杂优化的必然结果。主要包括和。
C++11特性的深度剖析：std::atomic在复杂数据结构中的高效应用
![C++的std::atomic（原子操作）](https://nixiz.github.io/yazilim-notlari/assets/img/thread_safe_banner_2.png) ...std::atomic是C++11标准库提供的一个模板类，专门用于实现原子操作，增强了并发控制能力。 #
【C++11新特性精讲】：std::atomic与volatile的6个不同应用场景
[【C++11新特性精讲】：std::atomic与volatile的6个不同应用场景](https://img-blog.csdnimg.cn/ce0c968e0dee4cf39ec138754a51793b.png) # 1. C++11新特性概述 ## 1.1 C++11的引入背景 C++11，作为C++语言的最新...
记录下原子操作的同步以及内存顺序
m0_62559200的博客
05-08 366
先解释几个点： 0.1、同步关系synchronizes-with 比如两条指令A和B是同步关系，则A是B的条件；A发生后B才能继续，且A之前的动作都发生在B前 0.2、先后关系happens-before:A之前的动作X，B之后的动作Y，X在Y前面。类似同步关系 1、memory_order_release的对象，会让其他所有线程，以memory_order_require方式看到的结果一致 2、memory_order_acquire会阻止原子操作之后的所有读和写被重排到原子操作之前 memo
C++ 并发编程指南（11）原子操作 | 11.4、通过内存序实现顺序模型
个人技术博客
05-14 1254
前文介绍了六种内存顺序，以及三种内存模型，本文通过代码示例讲解六种内存顺序使用方法，并实现相应的内存模型。
C++ memory order循序渐进（三）—— 原子变量上组合应用memory order实现不同的内存序
wxj1992的博客
01-05 7177
文章目录1.Relaxed ordering2.Release-Acquire ordering3.Release-Consume ordering4.Sequentially-consistent ordering5.总结 前面介绍了c++里一共有六种memory order，要达到数据同步的效果，需要进行组合使用，我们可以在两个地方指定memory order，一是atomic变量（原子变量）...
C++内存模型和原子类型操作
D_Guco的专栏
03-10 1125
c++ memory order 内存序
atomoic及其六个内存顺序
m0_57190374的博客
04-25 999
Atomic 是C++中的一种原子类型，也称为原子操作。它是一种不可分割的操作，可以确保多个线程同时对同一个共享变量的操作是安全的。Atomic的功能涵盖了多种操作，例如读取、更新、交换、加减等，可以确保这些操作在多线程环境中是原子性的，也就是说，操作不会被中断或改变。六个内存顺序： 1. memory_order_relaxed：不执行任何内存顺序约束，最灵活，但也最不安全。 2. memory_order_acquire：发生在acquire之前的任何操作，对acquire
模型内存顺序和原子操作顺序(1)
qq_19408603的博客
07-26 621
六个原子操作类型：memory_order_relaxed， memory_order_consume,memory_order_acquire, memory_order_release 对于acquire 和release， acquire 会等待release x.load 会失败，x.store 必然会先于x.load void write_x_then_y() {
C++并发编程之四 内存模型和原子操作
Awesomewan的博客
03-15 1829
这样会浪费时间和空间。需要注意的是，在test_and_set()和clear()方法中，我们都使用了内存序参数std::memory_order_acquire和std::memory_order_release，这是为了确保对内存的访问是有序的。除此之外，std::atomic<>泛化模板还支持一些其他的操作，如fetch_add、fetch_sub、fetch_and、fetch_or、fetch_xor等，这些操作可以原子地执行加法、减法、按位与、按位或和按位异或等运算，并返回操作前的值。
C++内存模型介绍
LT_lover的专栏
10-18 617
C++内存模型介绍。
c++——atomic以及内存顺序详解
Nieweishan的博客
08-11 1248
原子性操作库(atomic)是C++11中新增的标准库，它提供了一种线程安全的方式来访问和修改共享变量，避免了数据竞争的问题，对值进行在多线程的行为明确定义，使得不同的线程访问这个包含的值不会导致数据竞争，但是只支持基本数据类型，包括boolcharshortintlonglong long等基本数据类型，以及intmax_tuintmax_tintptr_t等扩展类型，对于用户自定义类型，需要使用 std::atomic。
fmt::print输出atomic
最新发布
11-11
在 C++ 中使用 `fmt::print` 输出 `std::atomic` 类型的值时，需要注意原子变量的特殊性质。以下是详细说明和示例： --- ## 1. 直接输出 `std::atomic` 值 `std::atomic` 可以直接当作普通值使用 `fmt::print` 输出，因为 `load()` 操作会自动执行： ```cpp #include <atomic> #include <fmt/core.h> int main() { std::atomic<int> atomic_int{42}; fmt::print("Atomic value: {}\n", atomic_int); // 自动调用 load() return 0; } ``` **输出结果**： ``` Atomic value: 42 ``` --- ## 2. 显式调用 `load()` 输出 如果需要更明确地控制内存顺序，可以显式调用 `load()`： ```cpp #include <atomic> #include <fmt/core.h> int main() { std::atomic<int> atomic_int{42}; // 显式指定内存顺序（顺序一致性） fmt::print("Atomic value: {}\n", atomic_int.load(std::memory_order_seq_cst)); return 0; } ``` --- ## 3. 输出指针类型的 `std::atomic` 对于原子指针，`fmt::print` 同样支持直接输出： ```cpp #include <atomic> #include <fmt/core.h> int main() { int value = 42; std::atomic<int*> atomic_ptr{&value}; fmt::print("Atomic pointer: {}\n", atomic_ptr); // 输出指针地址 fmt::print("Dereferenced value: {}\n", *atomic_ptr); // 解引用输出 return 0; } ``` --- ## 4. 自定义格式化输出 如果需要特殊格式（如十六进制），可以使用 `fmt` 的格式说明符： ```cpp #include <atomic> #include <fmt/core.h> int main() { std::atomic<int> atomic_int{42}; // 十六进制输出 fmt::print("Hex: 0x{:x}\n", atomic_int.load()); // 二进制输出 fmt::print("Binary: 0b{:b}\n", atomic_int.load()); return 0; } ``` **输出结果**： ``` Hex: 0x2a Binary: 0b101010 ``` --- ## 5. 注意事项 1. **线程安全**：`fmt::print` 本身不是原子操作，但输出 `std::atomic` 的值是安全的（因为先执行了原子加载） 2. **性能**：频繁调用 `fmt::print` 输出原子变量可能影响性能（考虑批量加载） 3. **内存顺序**：默认使用 `memory_order_seq_cst`，在需要高性能的场景可以指定更宽松的内存序 --- ## 6. 完整示例 ```cpp #include <atomic> #include <thread> #include <vector> #include <fmt/core.h> std::atomic<int> counter{0}; void increment(int n) { for (int i = 0; i < n; ++i) { counter.fetch_add(1, std::memory_order_relaxed); } } int main() { constexpr int kThreads = 4; constexpr int kIncrements = 100'000; std::vector<std::thread> threads; for (int i = 0; i < kThreads; ++i) { threads.emplace_back(increment, kIncrements); } for (auto& t : threads) { t.join(); } fmt::print("Final counter: {} (expected: {})\n", counter.load(), kThreads * kIncrements); return 0; } ``` **输出结果**： ``` Final counter: 400000 (expected: 400000) ``` ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值