一、为什么要用到volatile关键字？

使用一个新技术的原因肯定是当前存在了很多问题，在Java多线程的开发中有三种特性：原子性、可见性和有序性。我们可以在这里简单的说一下：

1、原子性（Atomicity）

原子性是指在一个操作中就是cpu不可以在中途暂停然后再调度，既不被中断操作，要不执行完成，要不就不执行，就好比你做一件事，要么不做，要么做完。java提供了很多机制来保证原子性。我们举一个例子，比如说常见的a++就不满足原子性。这个操作实际是a = a + 1；是可分割的。在运行的时候可能做了一半不做了。所以不满足原子性。

为了解决上面a++出现的问题，java提供了很多其他的关键字和类，比如说AtomicInteger、AtomicLong、AtomicReference等。

2、可见性(Visibility)

可见性就是指当一个线程修改了线程共享变量的值，其它线程能够立即得知这个修改。如果我们学过java内存模型的话，对下面这张图想必不陌生：

每一个线程都有一份自己的本地内存，所有线程共用一份主内存。如果一个线程对主内存中的数据进行了修改，而此时另外一个线程不知道是否已经发生了修改，就说此时是不可见的。

这种不可见的状况会带来一个问题，两个线程有可能会操作同一份但是值不一样的数据。这时候怎么办呢？于是乎，今天的主角登场了，这就是volatile关键字。

volatile关键字的作用很简单，就是一个线程在对主内存的某一份数据进行更改时，改完之后会立刻刷新到主内存。并且会强制让缓存了该变量的线程中的数据清空，必须从主内存重新读取最新数据。这样一来就保证了可见性

3、有序性

程序执行的顺序按照代码的先后顺序执行就叫做有序性，但是有时候程序的执行并不会遵循，比如说下面的代码：

int i = 1;              
int j = 2;

这两行代码很简单，i=1,j=2，程序在运行的时候一定会先让i=1，然后j=2嘛？不一定，为什么会不一定，这是因为有可能会发生指令重排序，从名字看就知道，在运行的时候，代码会重新排列。这里面涉及到的就比较多了。我会在专门的文章中进行讲解。

为了防止上面的重排序，java依然提供了很多机制，比如volatile关键字等。这也是我们volatile关键字第二个使用的场景。

在上面我们从java并发编程的三个特征来分析了为什么会用到volatile关键字，主要是保证内存可见性和防止指令重排序。下面我们就来正式来分析一下这个volatile。

二、深入剖析

1、volatile保证原子性嘛？

在上面我们只说了volatile关键字会保证可见性和有序性，但是并没有说会不会保证原子性，原子性的概念我们已经说了，也就是一个操作，要么不执行，要么执行到底。我们可以使用代码来验证一下：

public class Test {
    private static volatile int a = 0;
    public static void main(String[] args) {
        Test test = new Test();
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++) {
            threads[i] = new Thread(() -> {
                try {
                    for (int j = 0; j < 10; j++) {
                        System.out.println(++a);
                        Thread.sleep(500);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
            threads[i].start();
        }
    }
}

这段代码的含义是，有5个线程，每一个线程都对a进行递增。每个线程一次加10个数。按道理来讲，如果volatile关键字保证原子性的话，最后结果一定是50。我们可以运行一下看看结果：

最后得出的结论就是volatile不保证原子性。既然不能保证原子性，那肯定就是非线程安全的。

2、单例模式的双重锁为什么要加volatile？

什么是双重锁的单例模式，我们给出代码可以看看。

public class Test2 {
    private static volatile Test2 test2;
    public static Test2 getInstance() {
        if(test2 == null) {
            synchronized (Test2.class) {
                if(test2 == null) {
                    test2 = new Test2();
                }
            }
        }
        return test2;
    }
}

这就是单例模式的双重锁实现，为什么这里要加volatile关键字呢？我们把test2 = new Test2()这行代码进行拆分。可以分解为3个步骤：

（1）memory=allocate();// 分配内存

（2）ctorInstanc(memory) //初始化对象

（3）test2=memory //设置s指向刚分配的地址

如果没有volatile关键字，可能会发生指令重排序。在编译器运行时，从1-2-3 排序为1-3-2。此时两个线程同时进来的时候出现可见性问题，也就是说一个线程执行了1-3，另外一个线程一进来直接返回还未执行2的null对象。而我们的volatile关键之前已经说过了，可以很好地防止指令重排序。也就不会出现这个问题了。

如果我们学过java并发系列的其他类比如说Atomic等，通过源码我们会发现volatile无处不在。