211 lines
34 KiB
HTML
211 lines
34 KiB
HTML
<!DOCTYPE html>
|
|
<html lang="zh" dir="ltr" class="client-nojs" xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh">
|
|
<head><meta http-equiv="x-ua-compatible" content="ie=edge">
|
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
|
<title>memory_order</title>
|
|
<link rel="stylesheet" href="ext.css" />
|
|
<link rel="stylesheet" href="site_modules.css" />
|
|
</head>
|
|
<body class="mediawiki ltr sitedir-ltr ns-0 ns-subject page-c_atomic_memory_order skin-cppreference2 action-view cpp-navbar">
|
|
<div id="cpp-content-base">
|
|
<div id="content"><a id="top"></a>
|
|
<h1 id="firstHeading" class="firstHeading">memory_order</h1>
|
|
<div id="bodyContent">
|
|
<div id="contentSub"><span class="subpages">< <a href="c.html">c</a>‎ | <a href="c-atomic.html">atomic</a></span></div>
|
|
<div id="mw-content-text" lang="zh" dir="ltr" class="mw-content-ltr" xml:lang="zh">
|
|
<table class="t-dcl-begin">
|
|
<tbody>
|
|
<tr class="t-dsc-header">
|
|
<td>
|
|
<div>定义于头文件 <code><stdatomic.h></code></div>
|
|
</td>
|
|
<td></td>
|
|
<td></td>
|
|
</tr>
|
|
<tr class="t-dcl t-since-c11">
|
|
<td>
|
|
<div><span class="mw-geshi c source-c"><span class="kw2">enum</span> memory_order <span class="br0">{</span><br /></span>
|
|
<p> memory_order_relaxed,<br />
|
|
memory_order_consume,<br />
|
|
memory_order_acquire,<br />
|
|
memory_order_release,<br />
|
|
memory_order_acq_rel,<br />
|
|
memory_order_seq_cst<br /></p>
|
|
<span class="br0">}</span><span class="sy4">;</span></div>
|
|
</td>
|
|
<td class="t-dcl-nopad"></td>
|
|
<td><span class="t-mark-rev t-since-c11">(C11 起)</span></td>
|
|
</tr>
|
|
<tr class="t-dcl-sep">
|
|
<td></td>
|
|
<td></td>
|
|
<td></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<p><code>memory_order</code> 指定内存访问，包括常规的非原子内存访问，如何围绕原子操作排序。在没有任何制约的多处理器系统上，多个线程同时读或写数个变量时，一个线程能观测到变量值更改的顺序不同于另一个线程写它们的顺序。其实，更改的顺序甚至能在多个读取线程间相异。一些类似的效果还能在单处理器系统上出现，因为内存模型允许编译器变换。</p>
|
|
<p><a href="c-language-atomic.html">语言</a>和库中所有原子操作的默认行为提供<i>序列一致顺序</i>（见后述讨论）。该默认行为可能有损性能，不过可以给予库的原子操作额外的 <code>memory_order</code> 参数，以指定附加制约，在原子性外，编译器和处理器还必须强制该操作。</p>
|
|
<h3><span class="mw-headline" id=".E5.B8.B8.E9.87.8F">常量</span></h3>
|
|
<table class="t-dsc-begin">
|
|
<tr class="t-dsc-header">
|
|
<td colspan="2">
|
|
<div>定义于头文件 <code><stdatomic.h></code></div>
|
|
</td>
|
|
</tr>
|
|
<tr class="t-dsc-hitem">
|
|
<td>值</td>
|
|
<td>解释</td>
|
|
</tr>
|
|
<tr class="t-dsc">
|
|
<td><code>memory_order_relaxed</code></td>
|
|
<td>宽松操作：没有同步或顺序制约，仅对此操作要求原子性（见下方<a href="c-atomic-memory_order.html#.E5.AE.BD.E6.9D.BE.E9.A1.BA.E5.BA.8F">宽松顺序</a>）。</td>
|
|
</tr>
|
|
<tr class="t-dsc">
|
|
<td><code>memory_order_consume</code></td>
|
|
<td>有此内存顺序的加载操作，在其影响的内存位置进行<i>消费操作</i>：当前线程中依赖于当前加载的该值的读或写不能被重排到此加载前。其他释放同一原子变量的线程的对数据依赖变量的写入，为当前线程所可见。在大多数平台上，这只影响到编译器优化（见下方<a href="c-atomic-memory_order.html#.E9.87.8A.E6.94.BE.E6.B6.88.E8.B4.B9.E9.A1.BA.E5.BA.8F">释放消费顺序</a>）。</td>
|
|
</tr>
|
|
<tr class="t-dsc">
|
|
<td><code>memory_order_acquire</code></td>
|
|
<td>有此内存顺序的加载操作，在其影响的内存位置进行<i>获得操作</i>：当前线程中读或写不能被重排到此加载前。其他释放同一原子变量的线程的所有写入，能为当前线程所见（见下方<a href="c-atomic-memory_order.html#.E9.87.8A.E6.94.BE.E8.8E.B7.E5.BE.97.E9.A1.BA.E5.BA.8F">释放获得顺序</a>）。</td>
|
|
</tr>
|
|
<tr class="t-dsc">
|
|
<td><code>memory_order_release</code></td>
|
|
<td>有此内存顺序的存储操作进行<i>释放操作</i>：当前线程中的读或写不能被重排到此存储后。当前线程的所有写入，可见于获得该同一原子变量的其他线程（见下方<a href="c-atomic-memory_order.html#.E9.87.8A.E6.94.BE.E8.8E.B7.E5.BE.97.E9.A1.BA.E5.BA.8F">释放获得顺序</a>），并且对该原子变量的带依赖写入变得对于其他消费同一原子对象的线程可见（见下方<a href="c-atomic-memory_order.html#.E9.87.8A.E6.94.BE.E6.B6.88.E8.B4.B9.E9.A1.BA.E5.BA.8F">释放消费顺序</a>）。</td>
|
|
</tr>
|
|
<tr class="t-dsc">
|
|
<td><code>memory_order_acq_rel</code></td>
|
|
<td>带此内存顺序的读修改写操作既是<i>获得操作</i>又是<i>释放操作</i>。当前线程的读或写内存不能被重排到此存储前或后。所有释放同一原子变量的线程的写入可见于修改之前，而且修改可见于其他获得同一原子变量的线程。</td>
|
|
</tr>
|
|
<tr class="t-dsc">
|
|
<td><code>memory_order_seq_cst</code></td>
|
|
<td>有此内存顺序的加载操作进行<i>获得操作</i>，存储操作进行<i>释放操作</i>，而读修改写操作进行<i>获得操作</i>和<i>释放操作</i>，再加上存在一个单独全序，其中所有线程以同一顺序观测到所有修改（见下方<a href="c-atomic-memory_order.html#.E5.BA.8F.E5.88.97.E4.B8.80.E8.87.B4.E9.A1.BA.E5.BA.8F">序列一致顺序</a>）。</td>
|
|
</tr>
|
|
</table>
|
|
<table class="metadata plainlinks ambox mbox-small-left ambox-notice" style="">
|
|
<tr>
|
|
<td class="mbox-empty-cell"></td>
|
|
<td class="mbox-text" style="">本节未完成<br />
|
|
原因：先发生于和其他概念同 C++ ，但保持修改顺序和<a href="c-language-atomic.html">c/language/atomic</a>中的四种一致</td>
|
|
</tr>
|
|
</table>
|
|
<table class="metadata plainlinks ambox mbox-small-left ambox-notice" style="">
|
|
<tr>
|
|
<td class="mbox-empty-cell"></td>
|
|
<td class="mbox-text" style="">本节未完成<br />
|
|
原因：在做上面的时候，不要忘记在 C11 出版时先发生于不是不成环的，这经由 DR 401 被更新到匹配C++11</td>
|
|
</tr>
|
|
</table>
|
|
<h4><span class="mw-headline" id=".E5.AE.BD.E6.9D.BE.E9.A1.BA.E5.BA.8F">宽松顺序</span></h4>
|
|
<p>带标签 <span class="t-c"><span class="mw-geshi c source-c">memory_order_relaxed</span></span> 的原子操作无同步操作；它们不会在共时的内存访问间强加顺序。它们只保证原子性和修改顺序一致性。</p>
|
|
<p>例如，对于最初为零的 <code>x</code> 和 <code>y</code> ，</p>
|
|
<p><span class="t-c"><span class="mw-geshi c source-c"><span class="co1">// 线程 1 ：</span><br />
|
|
r1 <span class="sy1">=</span> <a href="c-atomic-atomic_load.html"><span class="kw933">atomic_load_explicit</span></a><span class="br0">(</span>y, memory_order_relaxed<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// A</span><br />
|
|
<a href="c-atomic-atomic_store.html"><span class="kw931">atomic_store_explicit</span></a><span class="br0">(</span>x, r1, memory_order_relaxed<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// B</span><br />
|
|
<span class="co1">// 线程 2 ：</span><br />
|
|
r2 <span class="sy1">=</span> <a href="c-atomic-atomic_load.html"><span class="kw933">atomic_load_explicit</span></a><span class="br0">(</span>x, memory_order_relaxed<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// C</span><br />
|
|
<a href="c-atomic-atomic_store.html"><span class="kw931">atomic_store_explicit</span></a><span class="br0">(</span>y, <span class="nu0">42</span>, memory_order_relaxed<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// D</span></span></span></p>
|
|
<p>允许产生结果 <code>r1 == 42 && r2 == 42</code> ，因为即使线程 1 中 A <i>先序于</i> B 且线程 2 中 C <i>先序于</i> D ，却没有制约避免 <code>y</code> 的修改顺序中 D 先出现于 A ，而 <code>x</code> 的修改顺序中 B 先出现于 C 。 D 在 <code>y</code> 上的副效应，可能可见于线程 1 中的加载 A ，同时 B 在 <code>x</code> 上的副效应，可能可见于线程 2 中的加载 C 。</p>
|
|
<p><br /></p>
|
|
<p>宽松内存顺序的典型使用是计数器自增，例如引用计数器，因为这只要求原子性，但不要求顺序或同步（注意计数器自减要求与析构函数进行获得释放同步）</p>
|
|
<h4><span class="mw-headline" id=".E9.87.8A.E6.94.BE.E6.B6.88.E8.B4.B9.E9.A1.BA.E5.BA.8F">释放消费顺序</span></h4>
|
|
<p>若线程 A 中的原子存储带标签 <span class="t-c"><span class="mw-geshi c source-c">memory_order_release</span></span> 而线程 B 中来自同一对象的读取存储值的原子加载带标签 <span class="t-c"><span class="mw-geshi c source-c">memory_order_consume</span></span> ，则线程 A 视角中<i>先发生于</i>原子存储的所有内存写入（非原子和宽松原子的），会在线程 B 中该加载操作所<i>携带依赖</i>进入的操作中变成<i>可见副效应</i>，即一旦完成原子加载，则保证线程B中，使用从该加载获得的值的运算符和函数，能见到线程 A 写入内存的内容。</p>
|
|
<p>同步仅在<i>释放</i>和<i>消费</i>同一原子对象的线程间建立。其他线程能见到与被同步线程的一者或两者相异的内存访问顺序。</p>
|
|
<p>所有异于 DEC Alpha 的主流 CPU 上，依赖顺序是自动的，无需为此同步模式产生附加的 CPU 指令，只有某些编译器优化收益受影响（例如，编译器被禁止牵涉到依赖链的对象上的推测性加载）。</p>
|
|
<p>此顺序的典型使用情况，涉及对很少被写入的数据结构（安排表、配置、安全策略、防火墙规则等）的共时读取，和有指针中介发布的发布者-订阅者情形，即当生产者发布消费者能通过其访问信息的指针之时：无需令生产者写入内存的所有其他内容对消费者可见（这在弱顺序架构上可能是昂贵的操作）。这种场景的例子之一是 <a href="https://en.wikipedia.org/wiki/Read-copy-update" class="extiw" title="enwiki:Read-copy-update">rcu 解引用</a>。</p>
|
|
<p><br /></p>
|
|
<p>注意到 2015 年 2 月为止没有产品编译器跟踪依赖链：均将消费操作提升为获得操作。</p>
|
|
<h4><span class="mw-headline" id=".E9.87.8A.E6.94.BE.E5.BA.8F.E5.88.97">释放序列</span></h4>
|
|
<p>若一些原子对象被存储-释放，而有数个其他线程对该原子对象进行读修改写操作，则会形成“释放序列”：所有对该原子对象读修改写的线程与首个线程同步，而且彼此同步，即使它们没有 <code>memory_order_release</code> 语义。这使得单产出-多消费情况可行，而无需在每个消费线程间强加不必要的同步。</p>
|
|
<h4><span class="mw-headline" id=".E9.87.8A.E6.94.BE.E8.8E.B7.E5.BE.97.E9.A1.BA.E5.BA.8F">释放获得顺序</span></h4>
|
|
<p>若线程 A 中的一个原子存储带标签 <span class="t-c"><span class="mw-geshi c source-c">memory_order_release</span></span> ，而线程 B 中来自同一变量的原子加载带标签 <span class="t-c"><span class="mw-geshi c source-c">memory_order_acquire</span></span> ，则从线程 A 的视角<i>先发生于</i>原子存储的所有内存写入（非原子及宽松原子的），在线程 B 中成为<i>可见副效应</i>，即一旦原子加载完成，则保证线程 B 能观察到线程 A 写入内存的所有内容。</p>
|
|
<p>同步仅建立在<i>释放</i>和<i>获得</i>同一原子对象的线程之间。其他线程可能看到与被同步线程的一者或两者相异的内存访问顺序。</p>
|
|
<p>在强顺序系统（ x86 、 SPARC TSO 、 IBM 主框架）上，释放获得顺序对于多数操作是自动进行的。无需为此同步模式添加额外的 CPU 指令，只有某些编译器优化受影响（例如，编译器被禁止将非原子存储移到原子存储-释放后，或将非原子加载移到原子加载-获得前）。在弱顺序系统（ ARM 、 Itanium 、 Power PC ）上，必须使用特别的 CPU 加载或内存栅栏指令。</p>
|
|
<p>互斥锁（例如<a href="c-thread.html#.E4.BA.92.E6.96.A5">互斥</a>或<a href="c-atomic-atomic_flag_test_and_set.html">原子自旋锁</a>）是释放获得同步的例子：线程 A 释放锁而线程 B 获得它时，发生于线程 A 环境的临界区（释放之前）中的所有事件，必须对于执行同一临界区的线程 B （获得之后）可见。</p>
|
|
<h4><span class="mw-headline" id=".E5.BA.8F.E5.88.97.E4.B8.80.E8.87.B4.E9.A1.BA.E5.BA.8F">序列一致顺序</span></h4>
|
|
<p>带标签 <span class="t-c"><span class="mw-geshi c source-c">memory_order_seq_cst</span></span> 的原子操作不仅以与释放/获得顺序相同的方式排序内存（在一个线程中<i>先发生于</i>存储的任何结果都变成进行加载的线程中的<i>可见副效应</i>），还对所有带此标签的内存操作建立<i>单独全序</i>。</p>
|
|
<p>正式而言，</p>
|
|
<p>每个加载原子对象 M 的 <code>memory_order_seq_cst</code> 操作 B ，观测到以下之一：</p>
|
|
<ul>
|
|
<li>修改 M 的上个操作 A 的结果，A 在单独全序中先出现于 B</li>
|
|
<li>或若存在这种 A ，则 B 可能观测到某些 M 的修改结果，这些修改非 <code>memory_order_seq_cst</code> 而且不<i>先发生于</i> A</li>
|
|
<li>或若不存在这种 A ，则 B 可能观测到某些 M 的无关联修改，这些修改非 <code>memory_order_seq_cst</code></li>
|
|
</ul>
|
|
<p>若存在 <code>memory_order_seq_cst</code>的 <span class="t-lc"><a href="c-atomic-atomic_thread_fence.html">atomic_thread_fence</a></span> 操作 X <i>先序于</i> B ，则 B 观测到以下之一：</p>
|
|
<ul>
|
|
<li>在单独全序中先出现于 X 的上个 M 的 <code>memory_order_seq_cst</code> 修改</li>
|
|
<li>在单独全序中后出现于它的某些 M 的无关联修改</li>
|
|
</ul>
|
|
<p>设有一对 M 上的原子操作，称之为 A 和 B ，这里 A 写入、 B 读取 M 的值，若存在二个 <code>memory_order_seq_cst</code> 的 <span class="t-lc"><a href="c-atomic-atomic_thread_fence.html">atomic_thread_fence</a></span> X 和 Y ，且若 A <i>先序于</i> X ， Y <i>先序于</i> B ，且 X 在单独全序中先出现于 Y ，则 B 观测到二者之一：</p>
|
|
<ul>
|
|
<li>A 的效应</li>
|
|
<li>某些在 M 的修改顺序中后出现于 A 的无关联修改</li>
|
|
</ul>
|
|
<p>设有一对 M 上的原子操作，称之为 A 和 B ，若符合下列条件之一，则 M 的修改顺序中 B 先发生于 A</p>
|
|
<ul>
|
|
<li>存在一个 <code>memory_order_seq_cst</code> 的 <span class="t-lc"><a href="c-atomic-atomic_thread_fence.html">atomic_thread_fence</a></span> X ，它满足 A <i>先序于</i> X ，且 X 在单独全序中先出现于 B</li>
|
|
<li>或者，存在一个 <code>memory_order_seq_cst</code> 的 <span class="t-lc"><a href="c-atomic-atomic_thread_fence.html">atomic_thread_fence</a></span> Y ，它满足 Y <i>先序于</i> B ，且 A 在单独全序中先出现于 Y</li>
|
|
<li>或者，存在 <code>memory_order_seq_cst</code> 的 <span class="t-lc"><a href="c-atomic-atomic_thread_fence.html">atomic_thread_fence</a></span> X 和 Y ，它们满足 A <i>先序于</i> X ， Y <i>先序于</i> B ，且 X 在单独全序中先出现于 Y</li>
|
|
</ul>
|
|
<p>注意这表明：</p>
|
|
<div class="t-li1"><span class="t-li">1)</span> 只要不带 <code>memory_order_seq_cst</code> 标签的原子操作进入局面，则立即丧失序列一致性</div>
|
|
<div class="t-li1"><span class="t-li">2)</span> 序列一致栅栏仅为栅栏自身建立全序，而不为通常情况下的原子操作建立（<i>先序于</i>不是跨线程关系，不同于<i>先发生于</i>）</div>
|
|
<p>若在多生产者-多消费者的情形中，且所有消费者都必须以相同顺序观察到所有生产者的动作出现，则可能必须有序列顺序。</p>
|
|
<p>全序列顺序在所有多核系统上要求完全的内存栅栏 CPU 指令。这可能成为性能瓶颈，因为它强制受影响的内存访问传播到每个核心。</p>
|
|
<h3><span class="mw-headline" id=".E4.B8.8E_volatile_.E7.9A.84.E5.85.B3.E7.B3.BB">与 volatile 的关系</span></h3>
|
|
<p>在执行线程中，不能将通过 <a href="c-language-volatile.html">volatile 左值</a>的访问（读和写）重排到同线程内为序列点所分隔的可观测副效应（包含其他 volatile 访问）后，但不保证另一线程观察到此顺序，因为 volatile 访问不建立线程间同步。</p>
|
|
<p>另外， volatile 访问不是原子的（共时的读和写是<a href="c-language-memory_model.html">数据竞争</a>），且不排序内存（非 volatile 内存访问可以自由地重排到 volatile 访问前后）。</p>
|
|
<p>一个值得注意的例外是 Visual Studio ，其中默认设置下，每个 volatile 写拥有释放语义，而每个 volatile 读拥有获得语义（ <a rel="nofollow" class="external text" href="http://msdn.microsoft.com/en-us/library/12a04hfd(v=vs.100).aspx">MSDN</a> ），故而可将 volatile 对象用于线程间同步。标准的 <span class="t-c"><span class="mw-geshi c source-c"><span class="kw4">volatile</span></span></span> 语义不可应用于多线程编程，尽管它们在应用到 <span class="t-c"><span class="mw-geshi c source-c"><a href="c-program-sig_atomic_t.html"><span class="kw499">sig_atomic_t</span></a></span></span> 对象时，足以与例如运行于同一线程的 <span class="t-lc"><a href="c-program-signal.html">signal</a></span> 处理函数交流。</p>
|
|
<h3><span class="mw-headline" id=".E7.A4.BA.E4.BE.8B">示例</span></h3>
|
|
<table class="metadata plainlinks ambox mbox-small-left ambox-notice" style="">
|
|
<tr>
|
|
<td class="mbox-empty-cell"></td>
|
|
<td class="mbox-text" style="">本节未完成<br />
|
|
原因：暂无示例</td>
|
|
</tr>
|
|
</table>
|
|
<h3><span class="mw-headline" id=".E5.BC.95.E7.94.A8">引用</span></h3>
|
|
<div class="t-ref-std-11">
|
|
<ul>
|
|
<li>C11 标准（ISO/IEC 9899:2011）：</li>
|
|
</ul>
|
|
<dl>
|
|
<dd>
|
|
<ul>
|
|
<li>7.17.1/4 memory_order (p: 273)</li>
|
|
</ul>
|
|
</dd>
|
|
</dl>
|
|
<dl>
|
|
<dd>
|
|
<ul>
|
|
<li>7.17.3 Order and consistency (p: 275-277)</li>
|
|
</ul>
|
|
</dd>
|
|
</dl>
|
|
</div>
|
|
<h3><span class="mw-headline" id=".E5.8F.82.E9.98.85">参阅</span></h3>
|
|
<table class="t-dsc-begin"></table>
|
|
<h3><span class="mw-headline" id=".E5.A4.96.E9.83.A8.E9.93.BE.E6.8E.A5">外部链接</span></h3>
|
|
<ul>
|
|
<li><a href="https://en.wikipedia.org/wiki/MOESI_protocol" class="extiw" title="enwiki:MOESI protocol">MOESI 协议</a></li>
|
|
</ul>
|
|
<table class="metadata plainlinks ambox mbox-small-left ambox-notice" style="">
|
|
<tr>
|
|
<td class="mbox-empty-cell"></td>
|
|
<td class="mbox-text" style="">本节未完成<br />
|
|
原因：我们在 QPI 、 MOESI 可能还有 Dragon 上找下好参考</td>
|
|
</tr>
|
|
</table>
|
|
<ul>
|
|
<li><a rel="nofollow" class="external text" href="http://www.cl.cam.ac.uk/~pes20/weakmemory/cacm.pdf">x86-TSO ： x86 多处理器上严格而有用的程序员模型</a>，P. Sewell 等， 2010</li>
|
|
<li><a rel="nofollow" class="external text" href="http://www.cl.cam.ac.uk/~pes20/ppc-supplemental/test7.pdf">ARM 及 POWER 宽松内存模型的入门教程</a>， P. Sewell 等 ， 2012</li>
|
|
<li><a rel="nofollow" class="external text" href="https://researchspace.auckland.ac.nz/bitstream/handle/2292/11594/MESIF-2009.pdf?sequence=6">MESIF ：点对点互联的两跳缓存一致性协议</a>， J.R. Goodman, H.H.J. Hum ， 2009</li>
|
|
</ul>
|
|
</div>
|
|
<div class="visualClear"></div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</body>
|
|
</html>
|