volatile是Java虚拟机提供的一个轻量级的同步机制；
它有三大特性：
1）.保证可见性
2）.不保证原子性
3）.禁止指令重排序
1.先要提及关于JMM（Java Memary model）模型的理解。也就是两个线程之间如何通信的问题。所有的数据都会经过主内存进行调用，主内存对应的硬件及是我们的内存条。当多个线程进入时，他们复制主内存的变量，到本地进行修改，然后通知给主内存，由有主内存通知其他线程。

通信过程如下：

2.Volatile保证可见性
上代码：

   MyTestNumber addTest = new MyTestNumber();
        // 线程1
        new Thread(() -> {
            System.out.println("获取该线程的名字:" + Thread.currentThread().getName() + "  b的值:" + addTest.b);
            try {
                // 故意停顿5秒
                Thread.sleep(5000);
                addTest.add2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("输出该线程的名字:" + Thread.currentThread().getName() + "  b的值:" + addTest.b);
        }, "线程1").start();

        // 线程2
        new Thread(() -> {
            while (addTest.b == 0) {
                // 一直等待，直到值改变为止
            }
            // 理论上，这里不会输出，会一直在上面的死循环中等待
            System.out.println("普通的没有有可见性，不知道线程中b的值已经发生变化了");
            System.out.println("输出该线程的名字:" + Thread.currentThread().getName() + "  b的值:" + addTest.b);
        }, "线程2").start();


    }

没有用volatile修饰的变量，就会一直进入死循环，因为在第一个线程中改变的值，无法通知到第二个线程

使用了Volatile修饰之后，再看输出的情况：

3.Volatile不保证原子性

 MyTestNumber myTestNumber = new MyTestNumber();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 2000; j++) {
                    myTestNumber.addPlus();
                }

            }, "线程").start();
        }
        // 等待线程执行完，再输出结果
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        // 如果保证了原子性，最终的结果永恒是20001
        System.out.println(Thread.currentThread().getName() + "\t finally number value :" + myTestNumber.i);
    }

分析过程，如果保证了原子性，输出的结果将是20001，如果由于多线程的原型，没有保证原子性，所以输出的结果是不同。

4.Volatile禁止指令重排
volatile的写-读与锁的释放-获取有相同的内存效果。

volatile写-读的内存语义：

当写一个volatile变量时，JMM会把线程A对应的本地内存中的共享变量值刷新到主内存。
当读一个volatile变量时，JMM会把线程B对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。

线程A写一个volatile变量，随后线程B读这个volatile变量，实质上是线程A通过主内存向线程B发送消息。

public class VolatileExample {
    int a = 0;
 
    volatile boolean flag = false;
 
    public void writer() {
        a = 1;
        flag = true;
    }
 
 
    public void reader() {
        if (flag) {
            System.out.println("resultValue:" + a);
        }
 
    }
}

为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。
案例代码地址在github：
https://github.com/virtuousOne/JavaBase