二:关于CPU乱序执行的学习

关于CPU的乱序执行

下列的demo用来演示CPU是否会进行乱序排序
定义四个变量a=0、b=0、x=0、y=0；
线程1：a=1,x=b;
线程2：b=1,y=a;输出x 和y的值
假设CPU不会进行乱序指令,
那么执行结果可能会有以下几种情况

以上无论是哪种情况,都不可能先执行x=b, y=a ; 即
x=0 和 y=0 都不可能同时出现

代码测试

/**
 * @author lrz 此程序用于测试cpu乱序执行
 */
public class Disorder {
    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        for(;;) {
            i++;
            x = 0; y = 0;
            a = 0; b = 0;
            Thread one = new Thread(new Runnable() {
                @Override
                public void run() {
                    //由于线程one先启动，下面这句话让它等一等线程two. 读着可根据自己电脑的实际性能适当调整等待时间.
                    shortWait(10000);
                    a = 1;
                    x = b;
                }
            });

            Thread other = new Thread(new Runnable() {
                @Override
                public void run() {
                    b = 1;
                    y = a;
                }
            });
            one.start();other.start();
            one.join();other.join();
            String result = "第" + i + "次 (" + "x="+x + "," +"y="+ y + "）";
            if(x == 0 && y == 0) {
                System.err.println(result);
                break;
            } else {
                System.out.println(result);
            }
        }
    }

    public static void shortWait(long interval){
        long start = System.nanoTime();
        long end;
        do{
            end = System.nanoTime();
        }while(start + interval >= end);
    }
}

测试结果

测试结果出现了x=0,y=0;说明CPU在执行的时候发生了乱序执行!

禁止乱序

CPU层面：Intel -> 原语(mfence lfence sfence) 或者锁总线
JVM层级：8个hanppens-before原则 4个内存屏障 （LL LS SL SS）
as-if-serial : 不管硬件什么顺序，单线程执行的结果不变，看上去像是serial

volatile实现(4个内存屏障SS SL LL LS)

java中的volatile在JVM层面中使用内存屏障来保证指令不会重排序;

volatile底层native方法中通过 lock addl指令实现,其中addl做了空实现,即在原有基础上增加0,等于没有操作,主要是通过该指令的lock实现内存屏障
volatile的两个功能:
1.保证线程间的可见性(底层通过MESI缓存一致性协议)
2.禁止指令重排序

8个happens-before原则

JVM规定重排序必须遵守的规则 JLS17.4.5
程序次序规则:同一个线程内,按照代码出现的顺序,前面的代码先行与后面的代码,准确的说是控制流顺序,因为要考虑到分支和循环结构.
管程锁定规则:一个unlock操作先行发生于后面(时间上)对同一个锁的lock操作.
volatile变量规则:对一个volatile变量的写操作先行发生于后面(时间上)对这个变量的读操作.
线程启动规则:Thread的start()方法先行发生于这个线程的每一个操作.
线程终止规则:线程的索引操作都先行于此线程的终止检测.可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测线程的终止.
线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生,可以通过Thread.interrupt()方法检测线程是否终端
对象终结规则:一个对象的初始化完成先行与发生它的finalize()方法的开始
传递性:如果操作A先行于操作B,操作B先行于操作C,那么操作A先行于操作C