Volatile的使用

volatile变量在Java中被看做是"程度较轻的synchronized"，与synchronized相比，volatile变量的编码较少，运行时开销也小，所以它所实现的功能也只是synchronized中的一部分。

Java内存模型中可见性，原子性，有序性

• 可见性
  线程之间的可见性，一个线程修改后的结果，另一个线程马上就能见到。比如：用volatile修饰的变量就具有可见性。volatile修饰的变量不允许内存缓存和重排序，是直接在内存中更改。volatile只能保证它所修饰内容的可见性，但是保证不了修饰内容的原子性。比如：volatile int a=1，这个操作之后是a+=1，这个变量具有可见性，但是a+=1它不是原子操作，也就是这个操作存在线程安全问题。
• 原子性
  原子是世界上最小的单位，具有不可分割性。比如：a=0这个操作不可分割，所以这个操作是原子操作；在比如：a+=1，这个操作可以分割为a=a+1，所以它不是原子操作。
• 有序性
  Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行执行。

根据上面的叙述，来分析下面的代码：

public class VolatileClass {
    private volatile int m = 0;

    public static void main(String[] args) throws InterruptedException {
        VolatileClass volatileClass = new VolatileClass();

       for (int i = 0; i < 4; i++) {

            Thread threadA = new Thread(volatileClass.new MyThread());
            threadA.start();

            Thread thread = new Thread(volatileClass.new MyThread());
            thread.start();

            threadA.join();
            thread.join();
            System.out.println("CurrThread:" + Thread.currentThread().getName() + ",m:" + volatileClass.m);
            volatileClass.m = 0;
        }
    }

    private class MyThread implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                inscribe();
            }
        }
    }

    private void inscribe() {
        m ++;
    }
}

程序运行之后，m的值最终为多少呢？2000?其实你多运行几次就会发现，它每次的值都不尽相同，但是都小于等于2000。看下面的运行结果：

CurrThread:main,m:1946
CurrThread:main,m:2000
CurrThread:main,m:2000
CurrThread:main,m:1754

将方法加上synchronized修饰，这样方法就具备了原子性，代码如下：

private synchronized void inscribe() {
        m += 1;
        System.out.println("CurrThread:" + Thread.currentThread().getName() + "-->m:" + m);
    }

运行程序：

CurrThread:main,m:2000
CurrThread:main,m:2000
CurrThread:main,m:2000
CurrThread:main,m:2000

看看JMM中内存与线程之间的关系？如下：

image.png
JMM中的内存分为主内存和工作内存，其中主内存是所有线程共享的，而工作内存是每个线程独立分配的，各个线程的工作内存之间相互独立、互不可见。在线程启动的时候，虚拟机为每个内存分配了一块工作内存，不仅包含了线程内部定义的局部变量，也包含了线程所需要的共享变量的副本，当然这是为了提高执行效率，读副本的比直接读主内存更快。

对于Volatile修饰的变量，当要获取值时，直接从内存中获取最新值；当要写入值时，也是直接写入内存，而不是从工作内存中。Volatile修饰的变量直接跳过了这一步。
当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。
在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。
当一个变量被定义为volatile时，就具备了两大特性：可见性和有序性。

volatile使用场景

要使用volatile必须具备以下两点：

• 对变量的写操作不依赖于当前值
• 该变量没有包含在具有其它变量的不变式中

事实上，上面的两个条件就是要保证volatile变量操作的原子性，这样才能使程序在并发的时候能够正确使用。
看如下代码：

public class VolatileClass {
    private boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        VolatileClass volatileClass = new VolatileClass();

        Thread threadA = new Thread(volatileClass.new MyThreadA());
        threadA.start();
        Thread.sleep(2000);
        volatileClass.flag = true;
        System.out.println("CurrThread:" + Thread.currentThread().getName() + ",flag:" + volatileClass.flag );
    }

    private class MyThreadA implements Runnable {

        @Override
        public void run() {
            while (!flag) {
                System.out.println("CurrThread:" + Thread.currentThread().getName() + " is Running...");
            }
        }
    }
}

我们根据上面介绍的JMM来分析下，子线程threadA在运行的时候，会把变量flag的值，从主内存拷贝到自己线程的工作内存之中，然后在执行while (!flag)的时候，从工作内存获取值进行判定。在主线程中执行语句volatileClass.flag = true;时，主线程也会先将变量flag的值，从主内存拷贝到自己线程的工作内存当中，然后修改flag=true，在写回主内存当中。所以安装分析，就算在主线程中设置了flag=true，子线程中的循环也不会停止。但是运行的结果，却是停止了，搞不懂哪里出问题了？
那么如果我们想在执行while (!flag)的时候每次都获取主内存中的值呢？这时候就要使用volatile了。更改代码为：

        private boolean flag = false;
替换为：
        private volatile boolean flag = false;

这样，当在主线程中设置flag=true后，循环就会停止了。