第 二 章：volatile关键字

主要讲解volatile的相关知识，以及容易遇到的坑。

一、volatile变量的特性

保证可⻅性，不保证原⼦性：

• 当写⼀个volatile变量时，JMM会把该线程本地内存中的变量强制刷新到主内存中去；
• 这个写会操作会导致其他线程中的volatile变量缓存⽆效。

禁⽌指令重排，我们回顾⼀下，重排序需要遵守⼀定规则：

• 重排序操作不会对存在数据依赖关系的操作进⾏重排序。⽐如：a=1;b=a; 这个指令序列，由于第⼆个操作依 赖于第⼀个操作，所以在编译时和处理器运⾏时这两个操作不会被重排序。
• 重排序是为了优化性能，但是不管怎么重排序，单线程下程序的执⾏结果不能被改变。 ⽐如： a=1;b=2;c=a+b这三个操作，第⼀步（a=1)和第⼆步(b=2)由于不存在数据依赖关系， 所以可能会发⽣重排 序，但是c=a+b这个操作是不会被重排序的，因为需要保证最终的结果⼀定是c=a+b=3。

二、volatile禁⽌指令重排规则

使⽤volatile关键字修饰共享变量便可以禁⽌这种重排序。若⽤volatile修饰共享变量，在编译时，会在指令序列中 插⼊内存屏障来禁⽌特定类型的处理器重排序，volatile禁⽌指令重排序也有⼀些规则：

• 当程序执⾏到volatile变量的读操作或者写操作时，在其前⾯的操作的更改肯定全部已经进⾏，且结果已经对 后⾯的操作可⻅；在其后⾯的操作肯定还没有进⾏；
• 在进⾏指令优化时，不能将对volatile变量访问的语句放在其后⾯执⾏，也不能把volatile变量后⾯的语句放到 其前⾯执⾏。

即执⾏到volatile变量时，其前⾯的所有语句都执⾏完，后⾯所有语句都未执⾏。且前⾯语句的结果对volatile 变量及其后⾯语句可⻅。

三、volatile禁⽌指令重排分析

该部分相关内容，我直接copy上⼀篇⽂章，不是为了凑篇幅，因为有同学没有看上⼀篇⽂章，直接看这篇， 为了能让每⼀篇⽂章能独⽴成章，可能会引⽤之前⽂章中的内容。

先看下⾯未使⽤volatile的代码：

class ReorderExample {
        int a = 0;
        boolean flag = false;
        public void writer() {
            a = 1; //1
            flag = true; //2
        }
        public void reader() {
            if (flag) { //3
                int i = a * a; //4
                System.out.println(i);
            }
        }
    }

因为重排序影响，所以最终的输出可能是0，，具体分析请参考我的上⼀篇⽂章《Java并发编程系列1-基础知 识》，如果引⼊volatile，我们再看⼀下代码：

class ReorderExample {
        int a = 0;
        boolean volatile flag = false;
        public void writer() {
            a = 1; //1
            flag = true; //2
        }
        public void reader() {
            if (flag) { //3
                int i = a * a; //4
                System.out.println(i);
            }
        }
    }

这个时候，volatile禁⽌指令重排序也有⼀些规则，这个过程建⽴的happens before关系可以分为两类：

1. 根据程序次序规则，1 happens before 2; 3 happens before 4。

2. 根据volatile规则，2 happens before 3。

3. 根据happens before 的传递性规则，1 happens before 4。

上述happens before关系的图形化表现形式如下：

在上图中，每⼀个箭头链接的两个节点，代表了⼀个happens before 关系。⿊⾊箭头表示程序顺序规则；橙⾊箭 头表示volatile规则；蓝⾊箭头表示组合这些规则后提供的happens before保证。

这⾥A线程写⼀个volatile变量后，B线程读同⼀个volatile变量。A线程在写volatile变量之前所有可⻅的共享变量， 在B线程读同⼀个volatile变量后，将⽴即变得对B线程可⻅。

四、volatile不适⽤场景

4.1 volatile不适合复合操作

下⾯是变量⾃加的示例：

public class volatileTest {
        public volatile int inc = 0;

        public void increase() {
            inc++;
        }
        public static void main(String[] args) {
            final volatileTest test = new volatileTest();
            for (int i = 0; i < 10; i++) {
                new Thread() {
                    public void run() {
                        for (int j = 0; j < 1000; j++)
                            test.increase();
                    };
                }.start();
            }

            while(Thread.activeCount()>1) //保证前⾯的线程都执⾏完
                Thread.yield();
            System.out.println("inc output:" + test.inc);

        }
    }

测试输出：

inc output:8182

因为inc++不是⼀个原⼦性操作，可以由读取、加、赋值3步组成，所以结果并不能达到10000。

4.2 解决⽅法

采⽤synchronized：

 public class volatileTest1 {
        public int inc = 0;
        public synchronized void increase() {
            inc++;
        }
        public static void main(String[] args) {
            final volatileTest1 test = new volatileTest1();
            for(int i=0;i<10;i++){
                new Thread(){
                    public void run() {
                        for(int j=0;j<1000;j++)
                            test.increase();
                    };
                }.start();
            }
            while(Thread.activeCount()>1) //保证前⾯的线程都执⾏完
                Thread.yield();
            System.out.println("add synchronized, inc output:" + test.inc);
        }
    }

采⽤Lock：

public class volatileTest2 {
        public int inc = 0;
        Lock lock = new ReentrantLock();
        public void increase() {
            lock.lock();
            inc++;
            lock.unlock();
        }
        public static void main(String[] args) {
            final volatileTest2 test = new volatileTest2();
            for(int i=0;i<10;i++){
                new Thread(){
                    public void run() {
                        for(int j=0;j<1000;j++)
                            test.increase();
                    };
                }.start();
            }
            while(Thread.activeCount()>1) //保证前⾯的线程都执⾏完
                Thread.yield();
            System.out.println("add lock, inc output:" + test.inc);
        }
    }

采⽤AtomicInteger：

public class volatileTest3 {
        public AtomicInteger inc = new AtomicInteger();
        public void increase() {
            inc.getAndIncrement();
        }
        public static void main(String[] args) {
            final volatileTest3 test = new volatileTest3();
            for(int i=0;i<10;i++){
                new Thread(){
                    public void run() {
                        for(int j=0;j<100;j++)
                            test.increase();
                    };
                }.start();
            }
            while(Thread.activeCount()>1) //保证前⾯的线程都执⾏完
                Thread.yield();
            System.out.println("add AtomicInteger, inc output:" + test.inc);
        }
    }

三者输出都是1000，如下：

add synchronized, inc output:1000
add lock, inc output:1000
add AtomicInteger, inc output:1000

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

先看⼀下单例代码：

public class penguin {
        private static volatile penguin m_penguin = null;
        // 避免通过new初始化对象
        private void penguin() {}
        public void beating() {
            System.out.println("打⾖⾖");
        };
        public static penguin getInstance() { //1
            if (null == m_penguin) { //2
                synchronized(penguin.class) { //3
                    if (null == m_penguin) { //4
                        m_penguin = new penguin(); //5
                    }
                }
            }
            return m_penguin; //6
        }
    }

在并发情况下，如果没有volatile关键字，在第5⾏会出现问题。instance = new TestInstance();可以分解为3⾏伪 代码：

a. memory = allocate() //分配内存
b. ctorInstanc(memory) //初始化对象
c. instance = memory //设置instance指向刚分配的地址

上⾯的代码在编译运⾏时，可能会出现重排序从a-b-c排序为a-c-b。在多线程的情况下会出现以下问题。当线程A在 执⾏第5⾏代码时，B线程进来执⾏到第2⾏代码。假设此时A执⾏的过程中发⽣了指令重排序，即先执⾏了a和c， 没有执⾏b。那么由于A线程执⾏了c导致instance指向了⼀段地址，所以B线程判断instance不为null，会直接跳到 第6⾏并返回⼀个未初始化的对象。

六 、何时使⽤volatile

⼤家对volatile变量的学习，关于重排序的规则，这个仅做了解即可，更重要的是掌握它的正常使⽤场景。那对于 锁和volatile，我们什么时候才会去使⽤volatile呢？我们先回顾⼀下volatile和锁的区别：

加锁机制既可以保证可⻅性，⼜可以保证原⼦性，⽽volatile变量只能保证可⻅性。

也就是我们只在可⻅性上，才去使⽤volatile变量，⽐如在多线程情况下，我们需要对某个操作的完成、发⽣中断 或者状态的标志，就可以声明为volatile，因为volatile可以保证该变量在所有线程的可⻅性。但是如果对于稍微复 杂的操作，⽐如i++等复合操作，就不要使⽤volatile变量，如果你想通过volatile的“禁⽌指令重排规则”来保证 volatile变量的前后变量代码的顺序性，建议你不要这样做，⼀⽅⾯有很多坑，另⼀⽅别⼈也不理解你的代码，⽐ 如我示例中的“volatile禁⽌指令重排分析”，即使我讲了⼀遍，我⾃⼰都很容易忘，你还指望别⼈能理解么？如果你 偏要这样去“炫技”，那你就是给别⼈埋坑了！就好⽐⼀⾏很简单的代码，有位程序员偏要⽤“&|”操作，结果埋个⼤坑，给部⻔造成S级的线上事故。

下⾯是《Java并发编程实战》的描述，我摘抄⼀下，其实有第⼀条不理解，仅做记录：

当且仅当满⾜以下所有条件时，才应该使⽤volatile变量：

• 对变量的写操作不依赖变量的当前值，或者你能确保只有单个线程更新变量的值。
• 该变量不会与其它状态变量⼀起纳⼊不可变的条件中。
• 在访问变量时不需要加锁。

七、总结

volatile可以保证线程可⻅性且提供了⼀定的有序性，但是⽆法保证原⼦性。在JVM底层volatile是采⽤“内存屏障”来 实现的。观察加⼊volatile关键字和没有加⼊volatile关键字时所⽣成的汇编代码发现，加⼊volatile关键字时，会多 出⼀个lock前缀指令，lock前缀指令实际上相当于⼀个内存屏障（也称内存栅栏），内存屏障会提供3个功能：

• 它确保指令重排序时不会把其后⾯的指令排到内存屏障之前的位置，也不会把前⾯的指令排到内存屏障的后⾯；即在执⾏到内存屏障这句指令时，在它前⾯的操作已经全部完成；
• 它会强制将对缓存的修改操作⽴即写⼊主存；
• 如果是写操作，它会导致其他CPU中对应的缓存⾏⽆效。

最后也讲解了volatile不适⽤的场景，以及解决的⽅法，并解释了单例模式为何需要使⽤volatile。