java多线程实战学习3-重排序

重排序

JVM为了优化代码，满足计算机多CPU，以及高速缓存等等，一言以蔽之，为了性能，可以对代码进行重排序，优化。
这个有个误区，重排序对于单线程的代码没有任何影响，不会因为重排序导致单线程代码出错。
例如单线程中

int a  = 0；
int b = 5;
int a = b;
int c = a;

这个代码单线程执行c永远等于5,不会出现c等于0的情况。
cpu重排序保证单线程代码的正确性。

例子

本文例子参考深入浅出 Java Concurrency (4): 原子操作 part 3 指令重排序与happens-before法则

但是文中的例子其实很难出现0,0情况，对此我进行了优化，让线程启动后sleep一段时间，从而保证后续代码能出现异常情况

public class ResortTest {

    static  int x = 0, y = 0, a = 0, b = 0;

    public static void main(String[] args) throws Exception {

        for (int i = 0; i < 1000; i++) {
            x = y = a = b = 0;
            Thread one = new Thread() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    a = 1;
                    x = b;
                }
            };
            Thread two = new Thread() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    b = 1;
                    y = a;
                }
            };
            one.start();
            two.start();
            one.join();

            two.join();
            if (x == 0 && y == 0) {
                System.out.println(x + " " + y);
            }
        }
    }

}

代码可能会变成

//线程A
x = b;
a = 1;
//线程B
y = a;
b = 1;

这样会导致0,0的情况发生。

笔者思考，还有一种情况，就是可见性。
假设没有发生重排序

//线程A
a = 1;
x = b;

//线程B
b = 1;
y = a;

线程A执行完a=1的时候， 线程B执行完b=1的时候，a和b的值都没有写入主存中，x,y取的仍然是历史脏数据0。会不会有这种可能呢？

可见性和重排序

这两者在书中都是成对出现的，解决方案还是volitate,它既能保证可见性，也能保证代码不被重新排序。
我们接上面的问题，可以使用volitate保证可见性和不被重排序，那么在代码中，将x,y,a加上voliate关键字，b不加。代码如下

public class ResortVisibilityTest {

    static volatile int x = 0;
    static volatile int y = 0;
    static volatile int a = 0;
    static  int b = 0;

    public static void main(String[] args) throws Exception {

        for (int i = 0; i < 10000; i++) {
            x = y = a = b = 0;
            Thread one = new Thread() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    a = 1;
                    x = b;
                }
            };

            Thread two = new Thread() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    b = 1;
                    y = a;
                }
            };
            one.start();
            two.start();
            one.join();

            two.join();
            if (x == 0 && y == 0) {
                System.out.println(x + " " + y);
            }
        }
    }

}

那么是否还是会出现0,0情况呢？答案是还是会出现。
分析如下 由于使用了volalite，那么代码不会重排。

//线程A
a = 1;
x = b;

//线程B
b = 1;
y = a;

线程B先执行了，这样才会出现y=0的情况，那么这个时候b肯定执行了1，那么x=b之后，x还是0,说明一个问题，就是线程B的数据 没有被写入主存中。x读取的是脏数据。