JAVA并发编程volatile核心原理

      上文说到synchronized，JAVA并发编程synchronized全能王的原理，虽然被评为并发全能王，不过用起来也是格外注意，不能搞大力出奇迹那一套，容易出现性能问题。比如synchronized是无法控制阻塞时长，阻塞不可中断问题；以及锁范围，修饰方法或代码块，要精细，仅修饰需要并发控制部分，降低锁粒度。文末再总结一下，synchronized和volatile的区别，先进入正题，聊聊正主：volatile。

      volatile是轻量级的并发解决方案，不会阻塞线程，是一种简单的同步机制。JAVA对volatile的定义是：volatile修饰的变量，在多线程并发读写场景下，可以保证变量的可见性和有序性。

---

1.如何保证有序性

      有序性：禁止指令重排优化。具体就是要求volatile修饰的变量操作（读写该变量的语句）后面的语句放到前面执行，也不能让将volatile变量操作之前的的语句延迟到后面执行。要求volatile变量前后语句按序执行，不许指令重排优化。比如如图，count是volatile修饰的int变量。在多线程并发到这一段代码语句123，CPU处理器就是按顺序执行。不好出现132顺序。

2.如何保证可见性

      保证此变量的修改，能被所有线程及时看到。具体是，线程改volatile修饰变量时，先改本地缓存变量副本，然后将本地变量副本值刷到主内存中。其他线程都volatile变量时，强制从主存也就是JVM堆内存读取变量最新值到线程本地缓存。

3.volatile实现可见性源码分析

        volatile实现可见性原理，其实就是：内存屏障（memory barrier）。内存屏障是一条CPU指令，用来控制在特定条件下的重排序和可见性问题。java编译器会根据内存屏障的规则禁止重排序。

        在对volatile变量写操作前，编译器会在写操作之后-》增加一个store屏障指令，让线程本地内存变量值能刷新到主内存中。

       在对volatile变量读操作前，编译器会在读操作之前《--增加一个load屏障指令，保证及时读到主内存的最新值。

总结起来，通俗的讲，就是CPU指令在对volatile修饰的变量修改后，会马上写入刷新到主内存中。CPU指令读volatile变量之前，强行要求cpu执行先读主内存该变量的最新值过来。这样就能读到其他线程修改后的最新值。

       看volatile的源码些微有点麻烦（需要对java代码进行javac编译，然后对.class文件进行javap处理），最后发现代码是hpp，汇编语言写的。不同操作系统实现不一样，比如jdk 8 linux x86是这个

       往细的讲，volatile为了保证变量的可见性，在java编译器编译代码指令时，对volatile修饰变量的读和写操作，都会在这个操作的前后插入屏障指令。

修改前，插入storestore屏障指令。

修改后，再次插入一个storeload屏障指令。

读前，插入一个loadStore屏障指令。

读后，插入一个loadload屏障指令。

4.volatile的缺点-原子性问题

      比如两个线程对一个volatile修饰的count字段，进行2w次++，由于原子性问题，导致结果并不是20000.

package lading.java.mutithread;

/**
 * volatile关键字存在原子性问题
 * 对volatile修饰的count进行20000次并发+1，预期结果是20000，但由于原子性问题，与预期不符
 * 
 */
public class Demo003VolatileBug {
    public static volatile int count = 0;//可以通过搭配CAS类对象来解决这个问题

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            //线程1对count进行10000次+1
            for (int i = 0; i < 10000; i++) {
                count++;
            }
            System.out.println(Thread.currentThread().getName()+"完成了对count10000次+1");
        });
        Thread thread2 = new Thread(() -> {
            //线程2,也对count进行100次+1
            for (int i = 0; i < 10000; i++) {
                count++;
            }
            System.out.println(Thread.currentThread().getName()+"完成了对count10000次+1");
        });
        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        System.out.println("两个子线程执行完毕后，count的值是："+count);
    }
}

结果，果然不是2w，只有1w多。

5.volatile怎么用更科学

       像4的示例，volatile修饰的count并发++2w次，结果出现原子性问题。可以通过使用CAS类来解决，比如两个都是轻量级方案，无锁，效率很高。

public static volatile AtomicInteger count = new AtomicInteger(0); 
//使用getAndIncrement 替换++ 
count.getAndIncrement();

以及搭配ReentrantLock可重入锁进行加锁处理，确保解决原子性问题。