面试干掉一大片—Java重排序

本是古典何须时尚 2021-07-24 18:43 289阅读 0赞

**简介：**  
重排序是指编译器和处理器为了优化性能而对指令序列进行重新排序的一种手段。

### 1、数据依赖性 ###

如果两个操作访问同一个变量，而且这两个操作中有一个操作为写操作，此时这两个操作之间存在数据依赖性。数据依赖性分为三种，如表所示：

<table> 
 <thead> 
  <tr> 
   <th><strong>名称</strong></th> 
   <th><strong>代码示例</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>写后读</td> 
   <td>a=1;b=a;</td> 
   <td>写一个变量后，再读这个位置</td> 
  </tr> 
  <tr> 
   <td>写后写</td> 
   <td>a=1;a=2;</td> 
   <td>写一个变量后，在写这个变量</td> 
  </tr> 
  <tr> 
   <td>读后写</td> 
   <td>a=b;b=1;</td> 
   <td>读一个变量后，再写这个变量</td> 
  </tr> 
 </tbody> 
</table>

上面的这三种情况，只要重排序了两个操作的执行顺序，程序的执行结果就会被改变。编译器和处理器针对单个处理器中执行的指令序列和单个线程中执行的操作重排序时，会遵守数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。（不同处理器和不同线程之间的数据依赖性不被编译器和处理器考虑）。

### 2、as-if-serial语义 ###

as-if-serial语义指的是：不管怎么重排序，**单线程执行**程序的执行结果不能被改变。编译器、runtime和处理器都必须遵守as-if-serial语义。  
为了遵守as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操作做重排序，因为 这种重排序会改变执行结果。但是，如果操作之间不存在数据依赖关系，这些操作就可能被编译器和处理器重排序。

举例说明，计算圆面积的代码示例：

double pi = 3.14;			// A
    double r = 1.0;				// B
    double area = pi * r;		// C

上面3个操作的数据依赖关系如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center]

**3个操作之间的依赖关系**  
**解释**：A和B之间存在数据依赖关系，同时B和C之间也存在数据依赖关系。因此在最终执行的指令序列中，C不可能被排到A和B的前面（C排到A和B的前面，程序的结果将会被改变）。但A和B之间没有数据依赖关系，编译器和处理器可重排序A和B之间的执行顺序。  
  
重排序后存在如下的执行可能：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center 1]  
总结：as-if-serial语义吧单线程程序保护起来了，遵守as-if-serial语义的编译器、runtime和处理器共同为编写单线程程序的程序员创建了一个**错误的幻觉**：**单线程程序是按程序的顺序来执行的**。as-if-serial语义使单线程程序员无需担心重排序会干扰他们，也无需担心内存可见性问题。

### 3、程序顺序规则 ###

根据happens-before的程序规则，上面计算圆的面积的示例代码存在3个happens-before关系。

1.  A happens-before B
2.  B happens-before C
3.  A happens-before C

**A happens-before C是根据1和2推导出来的。**  
虽然A happens-before B但是实际执行时B却可以排在A前面执行（在上面的执行图中）。如果A happens-before B，JMM并不要求A一定要在B之前执行，JMM仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前。这里A的执行结果不需要对B可见；而且重排序操作A和操作B后的执行结果，与A和操作B按happens-before顺序执行的结果一致。在这种情况下，JMM会认为这种重排序并不非法（not illegal），JMM运行这种重排序。  
在计算机中，软件技术和硬件技术有一个共同目标：再不改变程序执行结果的前提下，尽可能提高并行度。编译器和处理区遵从这一目标，从happens-before的定义我们可以看出，JMM同样也遵循这一目标。

### 4、重排序对多线程的影响 ###

**重排序是否会影响多线程的执行结果呢？**

package com.lizba.p1;
    
    /** * <p> * * </p> * * @Author: Liziba * @Date: 2021/6/7 23:01 */
    public class ReorderExample { 
    
        // 定义变量a
        int a = 0;
        // flag变量是个标记，用来标志变量a是否被写入
        boolean flag = false;
    
        public void writer() { 
            a = 1;                           // 1
            flag = true;                     // 2
        }
    
        public void reader() { 
            if (flag) {                       // 3
                int i = a * a;               // 4
                System.out.println("i:" + i);
            }
        }
    
    
        /** * 测试 * * @param args */
        public static void main(String[] args) { 
    
            final ReorderExample re = new ReorderExample();
    
            new Thread() { 
                public void run() { 
                    re.writer();
                }
            }.start();
    
            new Thread() { 
                public void run() { 
                    re.reader();
                }
            }.start();
        }
    
    }

这里假设两个线程A和B，A首先执行write()，B再执行readr()。线程B在执行操作4时，能否看到线程A在操作1对共享变量a的写入呢？  
**答案是：不一定能！**  
由于操作1和操作2没有数据依赖关系，编译器和处理器可以对这两个操作重排序；同样，操作3和操作4没有数据依赖关系，编译器和处理器也可以多这两个操作重排序。  
**假设操作1和操作2重排序：（虚箭线代表错误的读操作）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center 2]

**程序执行时序图**

如上图操作1和操作2发生了重排序。程序执行时，线程A首先写标记变量flag，随后线程B读取这个变量，条件判断为真，线程B读取变量a的值。此时，变量a还没有被线程A写入，在这里多线程程序的语义被重排序破坏了。  
  
**假设操作3和操作4重排序：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center 3]

**程序执行时序图**

在上述执行方式的程序中，操作3和操作4存在控制依赖关系。当代码中存在控制依赖性时，会影响指令并行度。为此编译器和处理器会采用猜测（Speculation）执行来克服控制相关性对并行度的影响。以处理器的猜测执行为例，执行现场B的处理器可提前读取并行计算a\*a，然后计算结果保存到一个名为重排序缓冲（Recorder Buffer, ROB）的硬件缓存中。当操作3的条件判断为真时，就把计算结果写入变量i中。  
在上图中可以看出，猜测执行实质上对操作3和4做了重排序。重排序在这里破坏了多线程程序的语义！  
在单线程程序中，对存在控制依赖性的操作重排序，不会改变执行结果（这也是as-if-serial语义允许对存在控制依赖的操作做重排序的原因）；但是在多线程中，对存在控制依赖的操作重排序，可能会改变程序的执行结果。

**文章总结至《Java并发编程艺术》，下篇总结“顺序一致性”，敬请关注。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center]: /images/20210724/60997d9ca2ef4dc28acf63b42543d73d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20210724/046a874523bf40b7a4508d08e9d4da6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20210724/705fae16c581495a86a62b36262c3a3e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20210724/bb22bf8e0715462a8f6921491f38e7bb.png