volatile的两大性质

一、可见性

1public class SynctestApplication {
2   
3   
4
5    //底层使用了lock指令实现锁缓存行
6    //-XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp
7    private volatile boolean flag = true;
8
9    public void refresh() {
10   
11   
12        flag = false;
13        System.out.println(Thread.currentThread().getName() + "fix flag");
14    }
15
16    public void load() {
17   
18   
19        System.out.println(Thread.currentThread().getName() + "start------");
20        int i = 0;
21        while (flag) {
22   
23   
24            i++;
25
26
27            /**
28             * 1、第一种情况，当线程B睡了两秒钟，修改了flag的值，但是A线程还在循环，并没有退出while循环 ---- 不能
29             */
30            //什么也不做
31
32            /**
33             * 2、睡一秒,跳出了while循环 ------ 能
34             * 不释放锁，让出cpu时间片，有线程上下文的切换
35             */
36            /*try {
37                Thread.sleep(1000);
38            } catch (InterruptedException e) {
39                e.printStackTrace();
40            }*/
41
42            /**
43             * 3、println，也可以跳出while循环      -------- 能
44             * synchronized 可见性保证  内存屏障
45             */
46
47            //System.out.println("-----------");
48
49            /**
50             * 4、shortWait()休眠纳秒
51             */
52
53            //休眠1秒 ----- 能
54            //shortWait(1000000); 缓存是否失效，线程栈中的缓存有个过期时间
55
56            //休眠0.1秒 ---- 不能
57            //shortWait(1000);
58        }
59        System.out.println(Thread.currentThread().getName() + "jump for: i= " + i);
60    }
61
62    public static void main(String[] args) {
63   
64   
65        SynctestApplication test = new SynctestApplication();
66        new Thread(() -> test.load(), "threadA").start();
67
68        try {
69   
70   
71            Thread.sleep(2000);
72            new Thread(() -> test.refresh(), "threadB").start();
73        } catch (InterruptedException e) {
74   
75   
76            e.printStackTrace();
77        }
78    }
79
80    //1毫秒=1000微秒 1毫秒=1000 000纳秒
81    public static void shortWait(long interval) {
82   
83   
84        //nanoTime()返回的是纳秒
85        long start = System.nanoTime();
86        long end;
87        do {
88   
89   
90            end = System.nanoTime();
91        } while(start + interval >= end);
92    }
93
94}

上图中是硬件架构，其实JMM内存模型和这个模型是一样的，只不过JMM操作的各个逻辑块，其实底层都是和上面的各个硬件有映射关系。
volatile的可见性其实就是利用了缓存一致协议（锁缓存行）（MESI）（M：修改 <----E：独占 <---- S：共享 <---- I：失效）。多个线程共享一个变量的时候，会将共享变量缓存到自己的缓存栈中，当当前这个变量是被valatile修饰的时候，那个这个变量所在的缓存行，就会被上面的MESI四种状态所标记，当前就会保证只要有一个线程修改了共享变量，总线利用总线嗅探会监测到当前的变化，并把其它缓存中的该变量的状态修改为I无效，其它线程如果需要获取该变量，都需要重新从主存中读取数据。
修改当前缓存中的共享变量对于当前线程来说是线程安全的，但是对被volatile修饰的变量来说，多个线程共同操作这个变量的时候，这个过程就不是线程安全的，所以volatile并不是线程安全的。下面是一个例子

1private static volatile long sum = 0;
2
3    public static void main(String[] args) {
4   
5   
6
7        for (int i=0; i<5; ++i) {
8   
9   
10            new Thread(()->{
11   
12   
13                for (int j=0; j<1000; ++j) {
14   
15   
16                    sum++;
17                }
18            }).start();
19        }
20
21        System.out.println(sum);//sum每次输出来的值，都不是我想要的
22}

注意：如果多个核的线程在操作同一个缓存行中的不同变量数据，那么就会出现频繁的缓存失效，即使在代码层面看这两个线程操作的数据之间完全没有关系。这种不合理的资源竞争情况就是伪共享

1public class FalseSharing {
2   
3   
4    public static void main(String[] args) {
5   
6   
7        try {
8   
9   
10            testPointer(new Pointer());
11        } catch (InterruptedException e) {
12   
13   
14            e.printStackTrace();
15        }
16    }
17
18    private static void testPointer(Pointer pointer) throws InterruptedException {
19   
20   
21        long start = System.currentTimeMillis();
22        Thread t1 = new Thread(() -> {
23   
24   
25            for (int i = 0; i < 100000000; i++) {
26   
27   
28                pointer.x++;
29            }
30        });
31
32        Thread t2 = new Thread(() -> {
33   
34   
35            for (int i = 0; i < 100000000; i++) {
36   
37   
38                pointer.y++;
39            }
40        });
41
42        t1.start();
43        t2.start();
44        t1.join();
45        t2.join();
46
47        System.out.println(System.currentTimeMillis() - start);
48    }
49}
50class Pointer {
51   
52   
53    /**
54     * 伪共享，缓存行一般是占用64个字节，下面的x和y总共占用的是8+8=16个字节，当两个线程分别对x和y进行修改时，会造成当前缓存行频繁失效，得不停地从主存中读取数据
55     * 这样就会对性能有所损耗
56     *
57     * 改进策略，浪费空间换取时间的策略，补齐64字节，让x和y分别在两个缓存行，这样在锁缓存行的时候，就不会出现频繁缓存行失效的情况
58     */
59    public volatile long x;
60    public long a,b,c,d,e,f,g;//避免伪共享，加上x刚好是64字节，没加这一行，执行时间大概是3秒，加了以后，执行时间是0.5毫秒
61    public volatile long y;
62}

二、有序性（实现了相当于内存屏障的功能）

1public class ReOrder {
2   
3   
4    //保证有序性，禁止重排序
5    private volatile static ReOrder myInstance;
6
7    public static ReOrder getMyInstance() {
8   
9   
10        if (myInstance == null) {
11   
12   
13            synchronized (ReOrder.class) {
14   
15   
16                if (myInstance == null) {
17   
18   
19                    /**
20                     * 单线程下，如果把2和3调换顺序，不会出现什么问题
21                     * 1、分配内存空间
22                     * 2、对象进行初始化
23                     * 3、将地址赋值给myInstance
24                     * 
25                     * 
26                     * 多线程的情况下
27                     * 1、分配内存空间
28                     * 3、将地址赋值给myInstance 
29                     * 2、对象进行初始化
30                     * 当执行完第二步的时候，myInstance已经有值了，此时，如果第二个线程进入到getmyInstance方法里面，第一个判断结果就会返回false，
31                     * 直接将myInstance的值返回，那么此时，就有可能对一个未初始化的对象做操作，那么加上volatile就可以防止，指令排序，2和3的位置也不会被调换
32                     */
33                    myInstance = new ReOrder();
34                }
35            }
36        }
37        return myInstance;
38    }
39
40    public static void main(String[] args) {
41   
42   
43        ReOrder.getMyInstance();
44    }
45}

为什么会有重排序呢？？？

从上图中可以看出来（1）（2）执行的结果都一样，但是对应的数据加载的指令却不一样，一个load代表从内存中加载一次数据通过高速缓存到cpu的过程，如果有重排序，那么就会减少一次这样的过程，这样的性能就比较高