volatile是java虚拟机提供的轻量级的同步机制它有三大特性，保证可见性，不保证原子性，禁止指令重排，想要了解volatile前，必须先理解JVM运行原理，以及JMM即java内存模型，由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（也可以称为栈空间），工作内存是每个线程的私有数据区域，而java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成。

    举个栗子来说明，假设JVM为我们开了三个线程来同时执行一段java程序，同时对变量A进行赋值，JVM会将变量A存在主内存中，初始値是0，这时有三个线程同时执行，首先三个线程都从主内存中将对象变量A拷贝到自己的工作内存中，由各自线程来修改，假设线程2比其他线程执行的快，将变量A赋值完后，拷回到主线程，这时，线程1和线程3,依然拿着被线程2修改前的变量A的值,这里会造成到数据的不一致性，如果线程2修改完变量A的值后，同时通知其他线程变量已经改变的这个动作，就是变量的可见性。

    下边我们通过一个栗子来看看变量不加volatile和加volatile修饰，有什么不同的结果，我们自定义一个资源类，并且定义一个number的变量，初始化为0，在定义一个方法，来改变这个变量值，开启一个新的线程调用改变number的方法，主线程根据变量的值，等待，或者结束。

public class VolatileDemo {

    public static void main(String[] args) {

        MyData myData = new MyData();

        new Thread(() -> {

            System.err.println(Thread.currentThread().getName() + "\t come in");
try {
Thread.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}

            myData.addTo60();

            System.err.println(Thread.currentThread().getName() + "\t update number value:" + myData.number);
}, "Thread 1").start();

        while (myData.number == 0) {

        }

        System.err.println("end");
}

}

class MyData {

    int number = 0;

    public void addTo60() {
this.number = 60;
}
}

执行结果，并且程序一直在转着，没有输出最后的end

Thread 1     come in
Thread 1     update number value:60

    这是小伙伴们就纳闷了，我已经将number的值修改为60了，程序为什么还是没有结束呢，这就是我们上边提到的，虽然主内存中的变量已经被修改完，但是，没有通知主线程，这是就能体会到volatile的作用，它是将主内存中变量修改完后，通知其他线程。我们在来可一个变量加上volatile的例子

public class VolatileDemo {

    public static void main(String[] args) {

        MyData myData = new MyData();

        new Thread(() -> {

            System.err.println(Thread.currentThread().getName() + "\t come in");
try {
Thread.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}

            myData.addTo60();

            System.err.println(Thread.currentThread().getName() + "\t update number value:" + myData.number);
}, "Thread 1").start();

        while (myData.number == 0) {

        }

        System.err.println("end");
}

}

class MyData {

    volatile int number = 0;

    public void addTo60() {
this.number = 60;
}
}

    从执行结果来看，最后的end被输出了，说明变量最新的值，已经对所有的线程可见。

Thread 1     come in
Thread 1     update number value:60
end

    接下来我们再来看看原子性，那什么是原子性呢，不可分割，完整性，当某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要整体完整，要么都成功，要么都失败，上边也讲过，volatile是不保证原子性的，我们在来看一个栗子，就是被volatile修饰的变量，我们启动20个线程，来volatile修饰的变量做1000次加加，看看最后结果是不是20000。

public class VolatileDemo {

    public static void main(String[] args) {

        MyData myData = new MyData();

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

            new Thread(() -> {

                for (int j = 0; j<1000; j++) {
myData.increment();
}

            }, "Thread " + String.valueOf(i)).start();
}

        System.err.println("myData.number=" + myData.number);

        System.err.println("end");
}

}

class MyData {

    volatile int number = 0;

    public void addTo60() {
this.number = 60;
}

    public void increment() {
number++;
}
}

我们多执行几次，结果每次都不一样，并且都没有到20000，说明，volatile是不保证原子性的

myData.number=18917
end

myData.number=17974
end

myData.number=18887
end

    这时会有小伙伴说，是不是20个线程没有计算完，程序就结束了呢，我们在来加一段粗体的代码，来控制20个线程结束后，最终number的值到没到20000呢。

public class VolatileDemo {

    public static void main(String[] args) {

        MyData myData = new MyData();

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

            new Thread(() -> {

                for (int j = 0; j < 1000; j++) {
myData.increment();
}

            }, "Thread " + String.valueOf(i)).start();
}

        while (Thread.activeCount() > 2) {
Thread.yield();
}

        System.err.println("myData.number=" + myData.number);

        System.err.println("end");
}

}

class MyData {

    volatile int number = 0;

    public void addTo60() {
this.number = 60;
}

    public void increment() {
number++;
}
}

    从运行结果来看，变量number的值还是没有到20000，对粗体的代码做一下解释，就是当前线程数大于2的时候，一直等待，其中两个线程中一个就是main线程，那是什么原因呢，为什么会出现这个现象呢，文章的开始我们简单的聊了下java内存模型，当JVM启动后，将number变量放到主内存中，这里开启的20个线程，将number变量拷贝到各自的工作内存中进行加加，当加加结束后，在拷回到主内存，由于，计算机运行的速度是非常的快，而且往主内存中写值的时候，只能有一个线程进行写的操作，就会出现写的覆盖，举个例子，线程1到20的线程同时拿到number变量的值，都为0，并且各自加1，当线程1比较快，将number的值持续加1，其他线程都在等待，当number的值变成3后，线程2拿到写number写的权限，由将number写成1，出现了写的覆盖，到这里大家就明白了为什么number在最后没有变成20000的原因了吧。

    那如何解决原子性的问题，第一个就是在方法上加上synchronized来修饰，也就是在上边资源类代码中number++的方法上加

class MyData {

    volatile int number = 0;

    public void addTo60() {
this.number = 60;
}

    public synchronized void increment() {
number++;
}
}

    这样在运行main方法的结果后，每次都是20000了，由于这里的synchronized 是对这个方法做了加锁的动作，这里只是做了变量加加的操作，如果还有其他的逻辑的话，每一个线程都会阻塞在那里，一直等待方法执行完，那显然不是一个好的解决方法，我们来看看其他的解决原子性的办法吧，那就是使用jdk的concurrent包下的（俗称JUC包）的原子类，例如AtomicInteger，AtomicLong，AtomicBoolean等，JUC包下，为基本类型int，long，boolean提供了原子类，还有一个就是对象引用的原子类AtomicReference，那我们用一段代码来看看原子类实现的number++。

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileDemo {

    public static void main(String[] args) {

        MyData myData = new MyData();

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

            new Thread(() -> {

                for (int j = 0; j < 1000; j++) {
myData.atomicIncrement();
}

            }, "Thread " + String.valueOf(i)).start();
}

        while (Thread.activeCount() > 2) {
Thread.yield();
}

        System.err.println("myData.ai=" + myData.ai);

        System.err.println("end");
}

}

class MyData {

    volatile int number = 0;

    public void addTo60() {
this.number = 60;
}

    public synchronized void increment() {
number++;
}

    public AtomicInteger ai = new AtomicInteger();

    public void atomicIncrement() {
ai.getAndIncrement();
}
}

    从每次的执行结果来看，依然都是20000，说明JUC包下的原子类也解决了原子性问题。

    接下来，我们简单聊聊volatile的禁止指令重排，我们写的java代码最终都会被编译成机器所能识别的机器码，也可称为指令，计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令重排，我们来看一个栗子。

public class ReSortSeqDemo {

    int a = 0;
boolean flag = false;

    public void method1() {

        a = 1;
flag = true;

    }

    public void method2() {

        if (flag) {
a = a + 5;
System.err.println("a = " + a);
}

    }

}

    这里method2中，flag是true的情况下，将a加5后，在打印，由于，计算机存在指令重排，这里method1中，计算机指令重排后，有可能flag=true被先执行，再来执行a=1，这样就会造成最后打印a的值，每次结果会有不同。

    那volatile用在什么地方呢，比较经典的就是当创建单例对象时的double check lock（DCL），双端检验锁，该机制不一定线程安全，原因是有指令重排存在，加入volatile可以禁止指令重排，我们来看看加了volatile修饰的DCL的单例的栗子。

public class SingletonDemo {

    private static volatile SingletonDemo instance = null;

    public SingletonDemo() {
System.err.println(Thread.currentThread().getName() + ":create intance");
}

    public static synchronized SingletonDemo getInstance() {
if (null == instance) {
synchronized (SingletonDemo.class) {
if (null == instance) {
instance = new SingletonDemo();
}
}
}
return instance;
}

    public static void main(String[] args) {
for (int i = 0; i < 20; i++) {

            new Thread(() -> {

                SingletonDemo.getInstance();

            }, "Thread " + String.valueOf(i)).start();
}
}

}

    volatile的讲解就到这里，现在只要是互联网项目，一定都会涉及到高并发，解决不好高并发问题，一定会出现数据不一致等，所以我们一定要理解好java高并发技术，下篇见。