目录

冯诺依曼计算机模型图：

现代计算机硬件结构原理图：

/** * 线程A改变initFlag属性之后，线程B马上感知到 */public class VolatileVisibilitySample {    volatile boolean initFlag = false;    public void save() {        this.initFlag = true;        String threadname = Thread.currentThread().getName();        System.out.println("线程：" + threadname + ":修改共享变量initFlag");    }    public void load() {        String threadname = Thread.currentThread().getName();        while (!initFlag) {            //线程在此处空跑，等待initFlag状态改变        }        System.out.println("线程：" + threadname + "当前线程嗅探到initFlag的状 态的改变");    }    public static void main(String[] args) {        VolatileVisibilitySample sample = new VolatileVisibilitySample();        Thread threadA = new Thread(() -> {            sample.save();        }, "threadA");        Thread threadB = new Thread(() -> {            sample.load();        }, "threadB");        threadB.start();        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        threadA.start();    }}

详解：

package my.mark.mybaibaoxiang.concurrent.jmmAndVolatile.jmm;/** * volatile的可见性：线程A改变initFlag属性之后，线程B马上感知到 */public class VolatileVisibilitySample {    //TODO 在这个共享变量加volatile关键字，可以让该变量变化时立马被别的线程嗅探到。    /**     * volatile是一个特征修饰符（type specifier）。     * volatile的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略，且//TODO 要求每次直接读值。     * volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。     */    private volatile boolean initFlag = false;    static Object object = new Object();    public void refresh(){        this.initFlag = true; //普通写操作，(相对于volatile写)        String threadname = Thread.currentThread().getName();        System.out.println("线程："+threadname+":修改共享变量initFlag");    }    public void load(){        String threadname = Thread.currentThread().getName();        int i = 0;        while (!initFlag){            //线程在此处空跑，等待initFlag状态改变            /**             * 如果此处不加synchronized同步代码块，则该线程可能会一直在跑，优先级比较高，别的线程抢不到他的cpu资源。             * TODO 如果此处加该同步代码块，initFlag值变化也会被感知到，             * 但原因是同步代码块有可能产生竞争和阻塞，导致两个线程上下文切换的时候，重新读取了initFlag的值。             */            synchronized (object){                i++;            }            //i++;        }        System.out.println("线程："+threadname+"当前线程嗅探到initFlag的状态的改变"+i);    }    public static void main(String[] args){        VolatileVisibilitySample sample = new VolatileVisibilitySample();        Thread threadA = new Thread(()->{            sample.refresh();        },"threadA");        Thread threadB = new Thread(()->{            sample.load();        },"threadB");        threadB.start();        try {             Thread.sleep(2000);        } catch (InterruptedException e) {            e.printStackTrace();        }        threadA.start();    }}

volatile缓存可见性实现原理 ：

1. JMM内存交互层面：volatile修饰的变量的read、load、use操作和assign、store、write必须是连续的，即修改后必须立即同步回主内存，使用时必须从主内存刷新，由此保证volatile变量的可见性。
2. 底层实现：通过汇编lock前缀指令，它会锁定变量缓存行区域并写回主内存，这个操作称为“缓存锁定”，缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据。一个处理器的缓存回写到内存内存会导致其他处理器的缓存无效。

public class VolatileVisibility {    public static volatile int i =0;    public static void increase(){        i++;    }}

        在并发场景下，i变量的任何改变都会立马反应到其他线程中，但是如果存在多条线程同时调用increase()方法的话，就会出现线程安全问题，毕竟i++;操作并不具备原子性，该操作是先读取值，然后写回一个新值，相当于原来的值加上1，分两步完成，如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值的加1操作，这也就造成了线程安全失败，因此对于increase方法必须使用synchronized修饰，以便保证线程安全，需要注意的是一旦使用synchronized修饰方法后，由于synchronized本身也具备与volatile相同的特性，即可见性，因此在这样种情况下就完全可以省去volatile修饰变量。

package my.mark.mybaibaoxiang.concurrent.jmmAndVolatile.jmm;/** * 双重检查锁定模式： * 经典的单例的双重检测的代码，这段代码在单线程环境下并没有什么问题，但如果在多线程环境下就可以出现线程安全问题。 * 原因在于某一个线程执行到第一次检测，读 取到的instance不为null时，instance的引用对象可能没有完成初始化。 */public class DoubleCheckLock {    private static DoubleCheckLock instance;    private DoubleCheckLock() {    }    public static DoubleCheckLock getInstance() {        //第一次检测        if (instance == null) {            //同步            synchronized (DoubleCheckLock.class) {                if (instance == null) {                    //多线程环境下可能会出现问题的地方                    instance = new DoubleCheckLock();                }            }        }        return instance;    }}

        上述代码一个经典的单例的双重检测的代码，这段代码在单线程环境下并没有什么问题，但如果在多线程环境下就可以出现线程安全问题。原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。

//禁止指令重排优化private volatile static DoubleCheckLock instance;

详解：

package my.mark.mybaibaoxiang.concurrent.jmmAndVolatile.jmm;/** * volatile禁止指令重排优化 * * 双重检查锁定模式： * 双重检查锁定模式（也被称为"双重检查加锁优化"，"锁暗示"（Lock hint）) 是一种软件设计模式用来减少并发系统中竞争和同步的开销。 * 双重检查锁定模式首先验证锁定条件(第一次检查)，只有通过锁定条件验证才真正的进行加锁逻辑并再次验证条件(第二次检查)。 * 该模式在某些语言在某些硬件平台的实现可能是不安全的。 * 它通常用于减少加锁开销，尤其是为多线程环境中的单例模式实现“惰性初始化”。惰性初始化的意思是直到第一次访问时才初始化它的值。 */public class Singleton {    /**     * 查看汇编指令（需安装Hsdis，工程下有。）     * -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp     */    private volatile static Singleton myinstance;//TODO 加volatile防止下面对象初始化时产生指令重排。    /**     * TODO 超高并发下的单例一定要像下面这样加双重锁     */    public static Singleton getInstance() {        if (myinstance == null) {            synchronized (Singleton.class) {//synchronized不保证代码块里不发生指令重排。                if (myinstance == null) {                    /**                     * TODO 对象创建过程，本质可以分为三步:                     * 1、申请内存空间address=allocate。2、实例化对象instance(Object)，向内存填充对象数据。3、将内存空间地址指向myinstance变量引用myinstance=address。                     * 三步没法保证原子性，也有可能发生指令重排。                     * 比方2和3颠倒，高并发下线程1执行了3，还没执行2，此时myinstance有地址指向已经不为null，但里面没值，则return之后操作里面便会空指针。                     */                    myinstance = new Singleton();                    //对象延迟初始化                    //                }            }        }        return myinstance;    }    public static void main(String[] args) {        Singleton.getInstance();    }}

汇编代码查看：

-XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp

volatile修饰字段指令前加锁：

/** * 与主内存-堆交互的便是volatile读或者写 * 在工作内存-栈中完成的便是普通读写。 */public class VolatileBarrierExample {    int a;    volatile int m1 = 1;    volatile int m2 = 2;    void readAndWrite() {        int i = m1;   // 第一个volatile读        int j = m2;   // 第二个volatile读        a = i + j;    // 普通写        m1 = i + 1;   // 第一个volatile写        m2 = j * 2;   // 第二个 volatile写    }}

5.2、cas和volatile关键字的使用会产生什么问题？总线风暴