多线程重排序

- 日理万妓 2022-01-31 02:43 233阅读 0赞

#### 重排序 ####

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

#### 数据依赖性 ####

如果两个操作访问同一个变量，且这两个操作中有一个为写操作，此时这两个操作之间就存在数据的依赖性。

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>代码实例</th> 
   <th>说明</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>

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

#### as-if-serial语义 ####

as-if-serial语义的意思是：不管怎样重排序，当然我们知道，重排序的目的是为了提高编译器和处理器的并行度，单线程的程序的执行结果不会被改变，这一点要注意，上面也提到了，这里的重排序针对的是单线程情况。编译器，runtime和处理器都必须遵守as-if-serial语义。为了遵守as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操作做重排序，因为这种重排序会改变程序执行结果。但是，如果操作之间不存在数据依赖关系，这些操作就可以被编译器和处理器重排序。

as-if-serial语义把单线程程序保护起来，遵守as-if-serial语义的编译器，runtime和处理器共同为编写单线程程序的程序员创建一个幻觉：单线程程序是按照程序的顺序来执行的。as-if-serial语义使单线程程序员无需担心重排序会干扰他们，也不用担心内存的可见性。

#### 程序顺序规则 ####

在计算机中，软件技术和硬件技术有一个共同的目标：在不改变程序的执行结果的前提下，尽可能提高并行度。处理器与编译器遵从这一目标，从happens-before的定义我们可以看出，JMM同样遵守。

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

在出现重排序的情况下，下面两个线程运行的结果可能会出现x=0且y=0的情况

import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    
    /**
     * @author ZerlindaLi create at 2019/5/15 11:04
     * @version 1.0.0
     * @description HappensBeforeDemo
     */
    public class HappensBeforeDemo {
    
        int a = 0;
        int b = 0;
        int x = -1;
        int y = -1;
    
        public void path1() {
            a = 1;
            x = b;
        }
    
        public void path2() {
            b = 2;
            y = a;
        }
    
        public boolean test() throws InterruptedException {
            a = b = 0;
            x = y = -1;
            CyclicBarrier cy = new CyclicBarrier(2);
            Thread t1 = new Thread(() -> {
                try {
                    cy.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                path1();
            });
            Thread t2 = new Thread(() -> {
                try {
                    cy.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                path2();
            });
    
            t1.start();
            t2.start();
    
            t1.join();
            t2.join();
    
    //        System.out.println("x="+x+", y="+y);
            if (x == 0 && y == 0) {
                return false;
            } else {
                return true;
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            for (int i = 0; i <= 300000; i++) {
                HappensBeforeDemo tt = new HappensBeforeDemo();
                boolean b = tt.test();
                if (!b) {
                    System.out.println(i);
                }
            }
        }
    }

我们让两个线程循环跑了30万次，出现了2次这样的结果  
![在这里插入图片描述][20190515142226625.png]

[20190515142226625.png]: /images/20220131/a0387245a06d4fb0a2fd4113db84f3fa.png