std::memory_order
来自cppreference.com
 |
该页由英文版wiki使用Google Translate机器翻译而来。
该翻译可能存在错误或用词不当。鼠标停留在文本上可以看到原版本。你可以帮助我们修正错误或改进翻译。参见说明请点击这里. |
| 在头文件 <atomic> 中定义
|
||
| enum memory_order { memory_order_relaxed, |
（C++11 起） | |
std::memory_order指定，非原子内存的访问是被下令周围的原子操作。这样做的理由是，当多个线程同时读写多核心系统上的多个变量，一个线程可能会“看到”另一个线程写入他们以不同的顺序值的变化比。此外，明显的顺序的变化可能在多个读取器线程是不同的。确保所有的内存访问原子变量是连续的，在某些情况下，可能会损害性能。 std::memory_order可以指定确切的限制，编译器必须执行.原文：
std::memory_order specifies how non-atomic memory accesses are to be ordered around an atomic operation. The rationale of this is that when several threads simultaneously read and write to several variables on multi-core systems, one thread might see the values change in different order than another thread has written them. Also, the apparent order of changes may be different across several reader threads. Ensuring that all memory accesses to atomic variables are sequential may hurt performance in some cases. std::memory_order allows to specify the exact constraints that the compiler must enforce.这是通过一个额外的参数，可以指定自定义的内存库中的每一个原子操作顺序。默认情况下是std::memory_order_seq_cst.
原文：
It's possible to specify custom memory order for each atomic operation in the library via an additional parameter. The default is std::memory_order_seq_cst.
目录 |
[编辑] 常量
| 在头文件
<atomic> 中定义 | |
| 值
|
Explanation |
memory_order_relaxed
|
“”轻松“的顺序：周围的原子变量的内存访问重新排序上没有任何限制.
原文： Relaxed ordering: there are no constraints on reordering of memory accesses around the atomic variable. |
memory_order_consume
|
“”消费“的操作：在当前线程没有读的价值依赖于当前加载的可以重新排序在此之前负载。这可确保写入到其他线程释放相同的原子变量的因变量是可见在当前线程。在大多数平台上，这会影响编译器的优化而已
原文： Consume operation: no reads in the current thread dependent on the value currently loaded can be reordered before this load. This ensures that writes to dependent variables in other threads that release the same atomic variable are visible in the current thread. On most platforms, this affects compiler optimization only. |
memory_order_acquire
|
“”获取“的操作：在当前线程没有读，在此之前负载可以重新排序。这将确保所有写在释放相同的原子变量的其他线程在当前线程是可见的.
原文： Acquire operation: no reads in the current thread can be reordered before this load. This ensures that all writes in other threads that release the same atomic variable are visible in the current thread. |
memory_order_release
|
“发行”的操作：可以重新排序后，这家店没有写在当前线程。这将确保所有的写操作在当前线程在其他线程获得相同的原子变量是可见的.
原文： Release operation: no writes in the current thread can be reordered after this store. This ensures that all writes in the current thread are visible in other threads that acquire the same atomic variable. |
memory_order_acq_rel
|
“”获取释放“操作：在当前线程没有读，在此之前负载，可以重新排序，以及没有在当前线程中写道这家店后，可以重新排序。该操作是读 - 修改 - 写操作。确保所有的写操作在另一个线程释放相同的原子变量是可见的改性前的和修改是可见的其他线程中获得相同的原子变量.
原文： Acquire-release operation: no reads in the current thread can be reordered before this load as well as no writes in the current thread can be reordered after this store. The operation is read-modify-write operation. It is ensured that all writes in another threads that release the same atomic variable are visible before the modification and the modification is visible in other threads that acquire the same atomic variable. |
memory_order_seq_cst
|
，顺序排列“。操作具有相同的语义获得释放操作，并且还具有顺序一致的操作顺序.
原文： Sequential ordering. The operation has the same semantics as acquire-release operation, and additionally has sequentially-consistent operation ordering. |
[编辑] 松散排序
std::memory_order_relaxed标记的原子操作具有以下性质：1
原文：
Atomic operations tagged std::memory_order_relaxed exhibit the following properties:
- 其他内存访问的顺序没有任何保证。这意味着它是不可能使用原子变量的多个线程同步.原文：No ordering of other memory accesses is ensured whatsoever. This means that it is not possible to synchronize several threads using the atomic variable.
- 读取和写入原子变量本身是有序的。一旦一个线程读取一个值，后续的读取相同的对象在同一个线程不能得到较早的价值.原文：Reads and writes to the atomic variable itself are ordered. Once a thread reads a value, a subsequent read by the same thread from the same object can not yield an earlier value.
例如，对于
x和y初始值为零原文：
For example, with
x and y initially zero,// Thread 1:
r1 = y.load(memory_order_relaxed);
x.store(r1, memory_order_relaxed);
// Thread 2:
r2 = x.load(memory_order_relaxed);
y.store(42, memory_order_relaxed);
被允许生产
r1 == r2 == 42.原文：
is allowed to produce
r1 == r2 == 42.[编辑] 发布消费
如果原子存储标签std::memory_order_release从相同的变量和原子加载标签std::memory_order_consume，操作具有以下性质：
原文：
If an atomic store is tagged std::memory_order_release and an atomic load from the same variable is tagged std::memory_order_consume, the operations exhibit the following properties:
- 没有写，写线程可以重新排序后的原子存储原文：No writes in the writer thread can be reordered after the atomic store
- 没有读取或写入依赖于接收到的值从原子负荷可以重新排序前的原子负载。 “依赖于”，是指从原子的变量的值的地址或值被计算。被称为“依赖排序”这种形式的线程之间的同步.原文：No reads or writes dependent on the value received from atomic load can be reordered before the atomic load. "Dependent on" means that the address or value is computed from the value of the atomic variable. This form of synchronization between threads is known as "dependency ordering".
- 建立了同步时仅线程之间的“释放”和“耗费”相同的原子变量。其他线程可以看到不同的顺序比一个或两个同步线程的内存访问.原文：The synchronization is established only between the threads releasing and consuming the same atomic variable. Other threads can see different order of memory accesses than either or both of the synchronized threads.
- 同步是传递的。也就是说，如果我们有下面的情况：原文：The synchronization is transitive. That is, if we have the following situation:
- 主题 A释放原子变量“A”.....
- 主题 B消耗原子变量“A”.....
- 原子变量“B”是依赖于“A”.....
- 主题“B”版本中的原子变量 B.
- 主题“C”使用或获取原子变量 B.原文：Thread C consumes or acquires atomic variable b.
-
- 那么，“A”和“B”或“B”和“C”是同步的，但“A”和“C”。也就是说，所有的线程中写道：“A”，推出之前发布的“A”，这样可以保证完成一次线程“C”观察店 B.原文：Then not only A and B or B and C are synchronized, but A and C also. That is, all writes by the thread A that were launched before the release of a are guaranteed to be completed once thread C observes the store to b.
在所有主流CPU，DEC的Alpha以外，依赖顺序是自动的，无需额外的CPU指令发出此同步模式，只有某些特定的编译器优化的影响（如编译器被禁止进行投机性负载的对象都参与了依赖链）
原文：
On all mainstream CPUs, other than DEC Alpha, dependency ordering is automatic, no additional CPU instructions are issued for this synchronization mode, only certain compiler optimizations are affected (e.g. the compiler is prohibited from performing speculative loads on the objects that are involved in the dependency chain)
[编辑] 释放序列
如果一些原子存储和其他几个线程执行读 - 修改 - 写操作的原子，“释放序列”形成的所有线程执行读 - 修改 - 写入相同的原子与第一个线程同步和即使他们有没有
memory_order_release语义。这使得单个生产者 - 多消费者的情况下，可能没有强加不必要的个人消费者线程之间的同步.原文：
If some atomic is store-released and several other threads perform read-modify-write operations on that atomic, a "release sequence" is formed: all threads that perform the read-modify-writes to the same atomic synchronize with the first thread and each other even if they have no
memory_order_release semantics. This makes single producer - multiple consumers situations possible without imposing unnecessary synchronization between individual consumer threads.[编辑] 释放获得订购
如果原子存储标签std::memory_order_release从相同的变量和原子加载标签std::memory_order_acquire，操作具有以下性质：
原文：
If an atomic store is tagged std::memory_order_release and an atomic load from the same variable is tagged std::memory_order_acquire, the operations exhibit the following properties:
- 没有写，写线程可以重新排序后的原子存储原文：No writes in the writer thread can be reordered after the atomic store
- 没有读取读取器线程可以重新排序前原子的负载.原文：No reads in the reader thread can be reordered before the atomic load.
- 只有在线程之间的同步建立“释放”和“收购”指同一个原子变量。其他线程可以看到不同的顺序比一个或两个同步线程的内存访问.原文：The synchronization is established only between the threads releasing and acquiring the same atomic variable. Other threads can see different order of memory accesses than either or both of the synchronized threads.
- 同步是传递的。也就是说，如果我们有下面的情况：原文：The synchronization is transitive. That is, if we have the following situation:
- 主题 A释放原子变量“A”.....
- 主题 B消耗原子变量“A”.....
- 主题“B”版本中的原子变量 B.
- 主题“C”使用或获取原子变量 B.原文：Thread C consumes or acquires atomic variable b.
-
- 那么，“A”和“B”或“B”和“C”是同步的，但“A”和“C”。也就是说，所有的线程中写道：“A”，推出之前发布的“A”，这样可以保证完成一次线程“C”观察店 B.原文：Then not only A and B or B and C are synchronized, but A and C also. That is, all writes by the thread A that were launched before the release of a are guaranteed to be completed once thread C observes the store to b.
在强烈的有序系统（包括x86和SPARC，IBM大型机），发行收购排序是自动的。没有额外的CPU指令发出此同步模式，只有某些特定的编译器优化的影响（如编译器禁止移动的原子存储脱膜剂的非原子店过去或执行非原子负载负载获得比原子）
原文：
On strongly-ordered systems (x86, SPARC, IBM mainframe), release-acquire ordering is automatic. No additional CPU instructions are issued for this synchronization mode, only certain compiler optimizations are affected (e.g. the compiler is prohibited from moving non-atomic stores past the atomic store-relase or perform non-atomic loads earlier than the atomic load-acquire)
[编辑] 顺序一致的顺序
如果原子存储和标签std::memory_order_seq_cst从相同的变量和原子加载标签std::memory_order_seq_cst，然后操作具有以下性质：
原文：
If an atomic store and an is tagged std::memory_order_seq_cst and an atomic load from the same variable is tagged std::memory_order_seq_cst, then the operations exhibit the following properties:
- 没有写，写线程可以重新排序后的原子存储原文：No writes in the writer thread can be reordered after the atomic store
- 没有读取读取器线程可以重新排序前原子的负载.原文：No reads in the reader thread can be reordered before the atomic load.
- 之间建立同步标记的原子操作std::memory_order_seq_cst。这种原子操作的所有线程使用相同的顺序内存访问.原文：The synchronization is established between all atomic operations tagged std::memory_order_seq_cst. All threads using such atomic operation see the same order of memory accesses.
顺序排列多个生产者多个消费者的情况下，所有的消费者都必须遵守所有生产者的行为发生在相同的顺序是必要的.
原文：
Sequential ordering is necessary for many multiple producer-multiple consumer situations where all consumers must observe the actions of all producers occurring in the same order.
总的顺序排列所有多核心系统上需要一个完整的的内存栅栏CPU指令。这可能会成为性能瓶颈，因为它迫使所有的内存访问，传播到每一个线程.
原文：
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.
[编辑] 与易挥发的关系
{{{1}}}
[编辑] 的例子
[编辑] std::memory_order_relaxed
下面的例子演示了一个任务（更新全局计数器），需要原子，但不涉及非原子内存的限制，因为没有排序.
原文：
The following example demonstrates a task (updating a global counter) that requires atomicity, but no ordering constraints since non-atomic memory is not involved.
#include <vector> #include <iostream> #include <thread> #include <atomic> std::atomic<int> cnt = ATOMIC_VAR_INIT(0); void f() { for(int n = 0; n < 1000; ++n) { cnt.fetch_add(1, std::memory_order_relaxed); } } int main() { std::vector<std::thread> v; for(int n = 0; n < 10; ++n) { v.emplace_back(f); } for(auto& t : v) { t.join(); } std::cout << "Final counter value is " << cnt << '\n'; }
输出：
Final counter value is 10000
[编辑] std::memory_order_release and std::memory_order_consume
这个例子演示了依赖有序的同步的整型数据是不相关的字符串的指针数据依赖关系，因此，它的价值是不确定的消费.
原文：
This example demonstrates dependency-ordered synchronization: the integer data is not related to the pointer to string by a data-dependency relationship, thus its value is undefined in the consumer.
#include <thread> #include <atomic> #include <cassert> #include <string> std::atomic<std::string*> ptr; int data; void producer() { std::string* p = new std::string("Hello"); data = 42; ptr.store(p, std::memory_order_release); } void consumer() { std::string* p2; while (!(p2 = ptr.load(std::memory_order_consume))) ; assert(*p2 == "Hello"); // never fires assert(data == 42); // may or may not fire } int main() { std::thread t1(producer); std::thread t2(consumer); t1.join(); t2.join(); }
[编辑] std::memory_order_release and memory_order_acquire
互斥体，并发队列和其他生产者 - 消费者的情况下需要发布的出版商线程的顺序，并获得消费者线程的顺序。这种模式建立两两线程之间的同步.
原文：
Mutexes, concurrent queues, and other producer-consumer situations require release ordering in the publisher thread and acquire ordering in the consumer thread. This pattern establishes pairwise synchronization between threads.
#include <thread> #include <atomic> #include <cassert> #include <string> std::atomic<std::string*> ptr; int data; void producer() { std::string* p = new std::string("Hello"); data = 42; ptr.store(p, std::memory_order_release); } void consumer() { std::string* p2; while (!(p2 = ptr.load(std::memory_order_acquire))) ; assert(*p2 == "Hello"); // never fires assert(data == 42); // never fires } int main() { std::thread t1(producer); std::thread t2(consumer); t1.join(); t2.join(); }
[编辑] std::memory_order_acq_rel
下面例子演示了传递的释放获得在三个线程
原文：
The follow example demonstrates transitive release-acquire ordering across three threads
#include <thread> #include <atomic> #include <cassert> #include <vector> std::vector<int> data; std::atomic<int> flag = ATOMIC_VAR_INIT(0); void thread_1() { data.push_back(42); flag.store(1, std::memory_order_release); } void thread_2() { int expected=1; while (!flag.compare_exchange_strong(expected, 2, std::memory_order_acq_rel)) { expected = 1; } } void thread_3() { while (flag.load(std::memory_order_acquire) < 2) ; assert(data.at(0) == 42); // will never fire } int main() { std::thread a(thread_1); std::thread b(thread_2); std::thread c(thread_3); a.join(); b.join(); c.join(); }
[编辑] std::memory_order_seq_cst
此示例演示顺序排列的情况下是必要的。任何其他顺序可能会触发断言，因为它的线程
c和d观察到原子x和y以相反的顺序将有可能.
原文：
This example demonstrates a situation where sequential ordering is necessary. Any other ordering may trigger the assert because it would be possible for the threads
c and d to observe changes to the atomics x and y in opposite order.
#include <thread> #include <atomic> #include <cassert> std::atomic<bool> x = ATOMIC_VAR_INIT(false); std::atomic<bool> y = ATOMIC_VAR_INIT(false); std::atomic<int> z = ATOMIC_VAR_INIT(0); void write_x() { x.store(true, std::memory_order_seq_cst); } void write_y() { y.store(true, std::memory_order_seq_cst); } void read_x_then_y() { while (!x.load(std::memory_order_seq_cst)) ; if (y.load(std::memory_order_seq_cst)) { ++z; } } void read_y_then_x() { while (!y.load(std::memory_order_seq_cst)) ; if (x.load(std::memory_order_seq_cst)) { ++z; } } int main() { std::thread a(write_x); std::thread b(write_y); std::thread c(read_x_then_y); std::thread d(read_y_then_x); a.join(); b.join(); c.join(); d.join(); assert(z.load() != 0); // will never happen }
