1.JMM模型

JMM 内存模型规范包括原子性、可见性、有序性。

1.volatile 解决了可见性

线程B执行了，将initFlag 值修改为false，线程A不是立即可见的。

A,B有自己的工作内存，A,B共享的变量在主内存。A,B对于initFlag 是对主内存的拷贝。B修改，A并不是立即可见，有一定延迟。

如果用volatile修饰，则是立即可见。

 

public class Jmm03_CodeVisibility {

    private   static boolean initFlag = false;
    //private  volatile   static boolean initFlag = false;
    private  static Integer counter = 0;

    public static void refresh(){
        log.info("refresh data.......");
        initFlag = true;
        log.info("refresh data success.......");
    }

    public static void main(String[] args){
        Thread threadA = new Thread(()->{
            while (!initFlag){
                //System.out.println("runing");
               //counter++;
            }
            log.info("线程：" + Thread.currentThread().getName()
                    + "当前线程嗅探到initFlag的状态的改变");
        },"threadA");
        threadA.start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread threadB = new Thread(()->{
            refresh();
        },"threadB");
        threadB.start();
    }
}

不用volatile 修饰，则A线程无法停止。

System.out.println("runing");//如果加上这段代码 ，A线程就可以停掉。while循环级别比较高。

2.volatile无法解决原子性

count++,

线程B修改了count，线程 A对count的操作会丢弃掉(volatile 可见性的机制）

public class Jmm04_CodeAtomic {

    private volatile static int counter = 0;
    static Object object = new Object();

    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(()->{
                for (int j = 0; j < 1000; j++) {
//                    synchronized (object){
                        counter++;//分三步- 读，自加，写回
//                    }
                }
            });
            thread.start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(counter);

    }
}

#计算结果，总的求和次数小于10000。每丢弃一次，就减少一次求和计算。

3.有序性 volatile 可以防止指令重排，实现有序性。

指令重排。代码行编译后可以不是严格按照顺序行执行。

 

private volatile static DoubleCheckLock instance;

 

这里应加入volatile ，防止new DoubleCheckLock 实例对象的过程中发生指令重排。