顺序一致性模型

谁借莪１个温暖的怀抱￠ 2024-03-16 09:45 34阅读 0赞

<table> 
 <thead> 
  <tr> 
   <th align="left"><code>顺序一致性内存模型</code>是一个理论参考模型，在设计的时候，<code>处理器的内存模型</code>和<code>编程语言的内存模型</code>都会以顺序一致性内存模型作为参照。</th> 
  </tr> 
 </thead> 
</table>

**JMM**对**数据竞争**的定义

<table> 
 <thead> 
  <tr> 
   <th align="left">Java内存模型规范对数据竞争的定义如下</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">在一个线程中<code>写</code>一个变量，在另一个线程<code>读</code>同一个变量，而且写和读<code>没有</code>通过同步来<code>排序</code>。</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">如果一个多线程程序能<code>正确</code>同步，这个程序将是一个<code>没有</code>数据竞争的程序。</td> 
  </tr> 
  <tr> 
   <td align="left">当程序<code>未</code>正确同步时，就可能会存在数据<code>竞争</code>。当代码中包含数据竞争时，程序的执行往往产生违反直觉的结果（<strong>就是<code>算错</code>了，这里说的委婉了</strong>）。</td> 
  </tr> 
 </tbody> 
</table>

JMM对**正确同步的多线程**程序的**内存一致性**做了如下保证

<table> 
 <thead> 
  <tr> 
   <th align="left"><strong><code>JMM</code>对<code>正确</code>同步的多线程程序的<code>内存一致性</code>做了如下<code>保证</code>。</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">如果程序是正确同步的，程序的执行将具有<code>顺序一致性</code>（Sequentially Consistent）——即程序的执行<code>结果</code>与该程序在<code>顺序一致性内存模型</code>中的执行结果<code>相同</code>。马上我们就会看到，这对于程序员来说是一个极强的保证。这里的同步是指广义上的同步，包括对常用同步原语（synchronized、volatile和final）的正确使用。</td> 
  </tr> 
 </tbody> 
</table>

**顺序一致性内存模型**

<table> 
 <thead> 
  <tr> 
   <th align="left">顺序一致性内存模型是一个被计算机科学家理想化了的<code>理论参考模型</code>，它为程序员提供了<code>极强</code>的内存可见性保证。顺序一致性内存模型有两大特性。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1）一个线程中的所有操作必须<code>按</code>照程序的<code>顺序</code>来执行。</td> 
  </tr> 
  <tr> 
   <td align="left">2）（不管程序是否同步）<strong>所有线程都只能看到一个<code>单一</code>的操作执行顺序</strong> （<strong>可能读不懂，看下面辅助理解例子第二图就明白了</strong>）。在顺序一致性内存模型中，每个操作都必须<code>原子</code>执行且<code>立刻</code>对所有线程<code>可见</code>。</td> 
  </tr> 
  <tr> 
   <td align="left">顺序一致性内存模型为程序员提供的视图如下图所示。</td> 
  </tr> 
  <tr> 
   <td align="left"><img src="https://img-blog.csdnimg.cn/d00303151229426091a1c6b1819fdcc2.png#pic_center" alt="image-20230608213157119"></td> 
  </tr> 
  <tr> 
   <td align="left">在概念上，顺序一致性模型有一个单一的全局内存，这个内存通过一个左右摆动的开关可以连接到任意一个线程，同时每一个线程必须按照程序的顺序来执行内存读/写操作。从上面的示意图可以看出，在任意时间点最多只能有一个线程可以连接到内存。当多个线程并发执行时，图中的开关装置能把所有线程的所有内存读/写操作串行化（即在顺序一致性模型中，所有操作之间具有<code>全序</code>关系）</td> 
  </tr> 
 </tbody> 
</table>

书中辅助理解的**例子**

<table> 
 <thead> 
  <tr> 
   <th align="left">假设有两个线程A和B并发执行。其中A线程有3个操作，它们在程序中的顺序是：A1→A2→A3。B线程也有3个操作，它们在程序中的顺序是：B1→B2→B3。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">假设这两个线程使用<code>监视器锁</code>来正确同步：A线程的3个操作执行后释放监视器锁，随后B线程获取同一个监视器锁。那么程序在顺序一致性模型中的执行效果将如下图所示</td> 
  </tr> 
  <tr> 
   <td align="left"><img src="https://img-blog.csdnimg.cn/e3dd59724dfd4aa8b9d8276892f065e9.png" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td align="left">我们再假设这两个线程<code>没有</code>做同步，下面是这个未同步程序在顺序一致性模型中的执行示意图，如下图所示</td> 
  </tr> 
  <tr> 
   <td align="left"><img src="https://img-blog.csdnimg.cn/826fcaf560114d70822c07b21f0e1c6c.png" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td align="left">未同步程序在顺序一致性模型中虽然整体执行顺序是<code>无序</code>的，但<code>所有线程都只能看到一个一致的整体执行顺序</code>。以上图为例，线程A和B看到的执行顺序都是：B1→A1→A2→B2→A3→B3。之所以能得到这个保证是因为顺序一致性内存模型中的每个操作必须<code>立即</code>对任意线程可见。</td> 
  </tr> 
  <tr> 
   <td align="left">但是，在JMM中就没有这个保证。未同步程序在JMM中不但整体的执行顺序是<code>无序</code>的，而且<code>所有线程看到的操作执行顺序也可能不一致</code>。比如，在当前线程把写过的数据缓存在本地内存中，在没有刷新到主内存之前，这个写操作仅对当前线程可见；从其他线程的角度来观察，会认为这个写操作根本没有被当前线程执行。只有当前线程把本地内存中写过的数据刷新到主内存之后，这个写操作才能对其他线程可见。在这种情况下，当前线程和其他线程看到的操作执行顺序将不一致。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">顺序一致性内存模型是一个理论参考模型，<code>JMM</code>和<code>处理器内存模型</code>在设计时通常会以顺序一致性内存模型为参照。在设计时，JMM和处理器内存模型会对顺序一致性模型做一些<code>放松</code>，因为如果完全按照顺序一致性模型来实现处理器和JMM，那么很多的处理器和编译器<code>优化</code>都要被禁止，这对执行<code>性能</code>将会有很大的影响。</th> 
  </tr> 
 </thead> 
</table>

同步程序的顺序一致性效果

class SynchronizedExample {
        
           int a = 0;
           boolean flag = false;
           public synchronized void writer() {
            // 获取锁
               a = 1;
               flag = true;
           }                                      // 释放锁
           public synchronized void reader() {
            // 获取锁
               if (flag) {
        
                   int i = a;
                   ……
               }                                  // 释放锁
           }
    }

<table> 
 <thead> 
  <tr> 
   <th align="left">在上面示例代码中，假设A线程执行writer()方法后，B线程执行reader()方法。这是一个正确同步的多线程程序。根据JMM规范，该程序的执行结果将与该程序在顺序一致性模型中的执行结果相同。下面是该程序在<code>两个内存模型中</code>的执行<code>时序</code>对比图，如下图所示。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><img src="https://img-blog.csdnimg.cn/09275e8796434d93af5b3e7d85646edb.png#pic_center" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td align="left">顺序一致性模型中，所有操作完全按程序的顺序串行执行。而在JMM中，临界区内的代码可以重排序。虽然线程A在临界区内做了重排序，但由于监视器互斥执行的特性，这里的线程B根本<code>无法</code>“观察”到线程A在临界区内的重排序。这种重排序既提高了执行效率，又没有改变程序的执行结果。</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">从这里我们可以看到，JMM在具体实现上的基本方针为： <strong><code>在不改变（正确同步的）程序执行结果的前提下，尽可能地为编译器和处理器的优化打开方便之门</code></strong>。</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

未同步程序的执行特性

<table> 
 <thead> 
  <tr> 
   <th align="left">对于未同步或未正确同步的多线程程序，JMM只提供<code>最小安全性</code>：线程执行时读取到的值，要么是<code>之前</code>某个线程写入的值，要么是<code>默认值</code>（0，Null，False），JMM保证线程读操作读取到的值不会无中生有（Out Of Thin Air）的冒出来。为了实现最小安全性，JVM在堆上分配对象时，首先会对内存空间进行<code>清零</code>，然后才会在上面分配对象（JVM内部会同步这两个操作）。因此，在已清零的内存空间（Pre-zeroed Memory）分配对象时，<code>域的默认初始化</code>已经完成了。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">JMM不保证未同步程序的执行结果与该程序在顺序一致性模型中的执行结果一致。因为如果想要保证执行结果一致，JMM需要禁止大量的处理器和编译器的优化，这对程序的执行性能会产生很大的影响。而且未同步程序在顺序一致性模型中执行时，整体是无序的，其执行结果往往无法预知。而且，保证未同步程序在这两个模型中的执行结果一致没什么意义。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">未同步程序在两个模型中的执行特性有如下几个<code>差异</code>。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1）顺序一致性模型<code>保证</code>单线程内的操作会按程序的顺序执行，而JMM<code>不保证</code>单线程内的操作会按程序的顺序执行</td> 
  </tr> 
  <tr> 
   <td align="left">2）顺序一致性模型<code>保证</code>所有线程只能看到一致的操作执行顺序，而JMM<code>不保证</code>所有线程能看到一致的操作执行顺序。</td> 
  </tr> 
  <tr> 
   <td align="left">3）顺序一致性模型<code>保证</code>对所有的内存读/写操作都具有原子性，而JMM<code>不保证</code>对64位的long型和double型变量的写操作具有原子性。</td> 
  </tr> 
  <tr> 
   <td align="left">第3个差异与<code>处理器总线</code>的<code>工作机制</code>密切相关。在计算机中，数据通过总线在处理器和内存之间传递。每次处理器和内存之间的数据传递都是通过一系列步骤来完成的，<strong>这一系列步骤称之为总线事务</strong>（Bus Transaction）。总线事务包括<code>读</code>事务（Read Transaction）和<code>写</code>事务（Write Transaction）。读事务从内存传送数据到处理器，写事务从处理器传送数据到内存，每个事务会读/写内存中<code>一个</code>或<code>多个</code>物理上连续的字。这里的关键是，<strong>总线会同步试图并发使用总线的事务</strong>。在一个处理器执行总线事务期间，总线会禁止其他的处理器和I/O设备执行内存的读/写。下面，让我们通过一个示意图来说明总线的工作机制，如下所示。</td> 
  </tr> 
  <tr> 
   <td align="left"><img src="https://img-blog.csdnimg.cn/c7cd9b97d5284f98be0ef426e0cd232e.png#pic_center" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td align="left">由图可知，假设处理器A，B和C同时向总线发起总线事务，这时总线仲裁（Bus Arbitration）会对竞争做出裁决，这里假设总线在仲裁后判定处理器A在竞争中获胜（总线仲裁会确保所有处理器都能<code>公平</code>的访问内存）。此时处理器A继续它的总线事务，而其他两个处理器则要等待处理器A的总线事务完成后才能再次执行内存访问。假设在处理器A执行总线事务期间（不管这个总线事务是读事务还是写事务），处理器D向总线发起了总线事务，此时处理器D的请求会被总线<code>禁止</code>。</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>总线的这些工作机制可以把所有处理器对内存的访问以<code>串行化</code>的方式来执行。在任意时间点，最多<code>只</code>能有<code>一个</code>处理器可以访问内存。这个特性<code>确保</code>了单个总线事务之中的内存读/写操作具有原子性。</strong></td> 
  </tr> 
 </tbody> 
</table>

\-----------------------------------------------------------------------------摘自 书名：Java并发编程的艺术 作者：方腾飞；魏鹏；程晓明