1. volatile的定义
Java编程语言允许线程访问共享变量,为了确保共享变量能被准确和一致性地更新,线程应该确保通过排他锁单独获取这个变量。Java语言提供了volatile,在某些情况下比锁更加方便。如果一个字段被声明成volatile关键字,Java线程内存模型确保所有线程看到这个变量值的一致性。
2.volatile的实现原则
1)Lock前缀指令会引起处理器缓存写回内存。Lock前缀指令导致在执行指令期间,声言处理器的Lock#信号。在多核处理器环境中,Lock#信号确保在声言该信号期间,处理器可以独占任何共享内存。
2)一个处理器的缓存写会内存会导致其他处理器的缓存失效。(根据MESI协议
3.volatile的自身特性(自身角度分析特性)
理解volatile特性的一个好方法是把对volatile变量的单个读/写,看成是使用同一个锁对这些单个读/写操作做了同步。如下两个代码示例:
volatile关键字代码:

public class VolatileFeaturesExample {

    volatile long v1 = 0L;

    public void set (long v2) {
        this.v1 = v2;
    }

    public long get () {
        return v1;
    }

    public void getAndIncrement() {
        v1++;
    }

    public static void main(String[] args) {
        VolatileFeaturesExample v = new VolatileFeaturesExample();
        /*new Thread(new ThreadSet(v)).start();
        new Thread(new ThreadGet(v)).start();*/
        final CountDownLatch countDownLatch = new CountDownLatch(5000);
        for (int i = 0;i < 5000;i ++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    v.getAndIncrement();
                    countDownLatch.countDown();
                }
            }).start();
        }
        try {
            countDownLatch.await();
            System.out.println(v.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class ThreadGet implements Runnable {
        private VolatileFeaturesExample v;

        public ThreadGet (VolatileFeaturesExample v) {
            this.v = v;
        }

        public void run() {
            long local_v1 = 0L;
            while (local_v1 <10) {
                if (local_v1 != v.get()) {
                    System.out.println("ThreadGet--------------"+v.get());
                    local_v1 = v.get();
                }
            }

        }

    }

    static class ThreadSet implements Runnable {

        private VolatileFeaturesExample v;

        public ThreadSet (VolatileFeaturesExample v) {
            this.v = v;
        }

        public void run() {
            long local_v1 = 0L;
            while (local_v1 < 10) {
                System.out.println("ThreadSet----------"+(++local_v1));
                v.set(local_v1);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

把volatile改为锁synchronized。(这里只贴了方法代码,其它和上面一样)

long v1 = 0L;

    public synchronized void set (long v2) {
        this.v1 = v2;
    }

    public synchronized long get () {
        return v1;
    }

代码分析:
get和set方法执行结果
(1)加了volatile关键字的执行结果

ThreadSet----------1
ThreadGet--------------1
ThreadSet----------2
ThreadGet--------------2
ThreadSet----------3
ThreadGet--------------3
ThreadSet----------4
ThreadGet--------------4
ThreadSet----------5
ThreadGet--------------5
ThreadSet----------6
ThreadGet--------------6
ThreadSet----------7
ThreadGet--------------7
ThreadSet----------8
ThreadGet--------------8
ThreadSet----------9
ThreadGet--------------9
ThreadSet----------10
ThreadGet--------------10

(2)去掉volatile执行结果

ThreadSet----------1
ThreadGet--------------1
ThreadSet----------2
ThreadSet----------3
ThreadSet----------4
ThreadSet----------5
ThreadSet----------6
ThreadSet----------7
ThreadSet----------8
ThreadSet----------9
ThreadSet----------10

(3)去掉volatile关键字,换成锁synchronized的执行结果

ThreadSet----------1
ThreadGet--------------1
ThreadSet----------2
ThreadGet--------------2
ThreadSet----------3
ThreadGet--------------3
ThreadSet----------4
ThreadGet--------------4
ThreadSet----------5
ThreadGet--------------5
ThreadSet----------6
ThreadGet--------------6
ThreadSet----------7
ThreadGet--------------7
ThreadSet----------8
ThreadGet--------------8
ThreadSet----------9
ThreadGet--------------9
ThreadSet----------10
ThreadGet--------------10

getAndIncrement执行结果
(4)使用带有volatile关键字的v1,调用getAndIncrement累加到5000

第一次:5000
第二次:5000
第三次:4999
第四次:5000
第五次:4999

如上面示例代码所示,一个volatile变量的读/写操作,与一个普通变量的读/写使用锁同步,它们之间的执行结果不同。不使用volatile关键字,发现一个线程改线,另一个线程可能都不可见。
锁的happens-before规则保证释放锁和获取锁的两个线程之间的内存可见性,这意味着对于一个volatile变量的读,总是能看到(任意线程)对这个volatile变量最后的写入。
锁的语义决定了临界区代码执行具有原子性。这意味,即使64位的long型和double变量,只要它是volatile变量,对该该变量的读/写就具有原子性。根据代码getAndIncrement方法结果得知,对于volatile++这种复合操作不就有原子性,这些操作本身不具有原子性。
特性
(1)可见性。对于一个volatile变量的读,总是能看到(任意线程)对这个volatile变量的最后写入。
(2)原子性。对任意单个volatile变量的读/写具有原子性,但类似volatile++这种操作不具有原子性。
4.volatile特性的影响性(从不是volatile变量的角度分析,volatile给它们带来的内存可见性影响)
1)volatile 写/读建立的happens-before关系
其实volatile保证了可见性,其实就是完成了线程之间的通信。
我们来分析下如下代码的happens-before关系

int num = 0;
    volatile boolean flag = false;

    public void write (int i) {
        num = i;  // 1
        flag = true;// 2
    }

    public  int read () {
        if (flag) { // 3
            int i = num; // 4
            return i;
        }
        return num;
    }

(1)根据程序次序规则,1happens-before2;3happens-before4;
(2)根据volatile规则,2happens-before3;
(3)根据happens-before的传递规则,1happens-before4;
我们发现一个问题volatile影响了普通的字段,可以理解为write的普通num写对read的普通读num可见了,根据1happens-before来判断。
代码测试,测试volatile对普通变量的影响:
影响特性
(1)任何变量的写在volatile变量写之前,那么这个变量在volatile变量读之后是可见的.(具体解释原理第6点中详解)
5.volatile内存语义实现
1)volatile重排序规则表
(1)当第二个操作是volatile写时,不管第一个操作是什么,都不能重排序。这个规则确保volatile写之前的操作不会被编译器重排序到volatile之后。
(2)当第一个是volatile读时,不管第二个操作是什么,都不能重排序。这个规则确保volatile读之后的操作不会被编译器重排序到volatile之前。
(3)当第一个操作是volatile写,第二个操作volatile时,不能进行重排序。
2)限制重排序的规则(内存屏障)
(1)在每个volatile写操作的前面插入一个StoreStore屏障。
(2)在每个volatile写操作的后面插入一个StoreLoad屏障。
(3)在每个volatile读操作的后面插入一个LoadLoad屏障。
(4)在每个volatile读操作的后面插入一个LoadStore屏障。
上面的内存屏障都非常保守,但它可以保证任意处理器平台,任意程序中都能得到正确的volatile语义。
3)代码示例分析
(1)volatile写插入的内存屏障
内存语义:当写一个volatile变量时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存。
实现写语义的内存屏障:StoreStore和StoreLoad。如下图执行指令执行顺序
Volatile 关键字浅析
StoreStore屏障可以保证在volatile写之前,前面所有的普通写操作已经对任何处理器可见了。这是因为StoreStore屏障将保证上面所有的普通写在volatile写之前刷新到主内存。
这里比较有意思的是,volatile写后面的StoreLoad屏障。此屏障的作用是避免volatile写与后面可能有的volatile读/写操作重排序。因为编译器常无法准确判断一个volatile写的后面是否需要插入一个StoreLoad屏障。为了保证能正确实现volatile的内存语义,JMM实现了保守策略:在每个volatile写的后面或者每个volatile读前面插入一个StoreLoad屏障。从整体的执行效率角度考虑,JMM最终选择了在在每个volatile写的后面插入一个StoreLoad屏障。因为volatile写-读内存语义的常见模式是:一个线程写volatile变量,读个线程读取volatile读取同一个volatile变量。当读线程的数量大大超过写线程时,选择在volatile写之后插入StoreLoad屏障将带来可观的执行效率的提升。
(2)volatile读插入的内存屏障
Volatile 关键字浅析

LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序。LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序。

6、通过内存屏障(Memory Barrier)分析volatile实现
代码示例:

public class VolatileTest {

    private  boolean vonum = false;
    private  int num = 0;

    // thread1
    public void write (int i) {
        num = i;
        // 插入StoreStore屏障
        vonum = true;
        // 插入StoreLoad屏障
    }

    // thread2
    public void read () {
        if (vonum) {
            // 插入LoadLoad屏障
            // 插入LoadStore屏障
            System.out.println(Thread.currentThread().getName()+"---"+num);
        }
    }

分析:
1)、LoadLoad:在volatile读后面有一个LoadLoad屏障,它保证了屏障前的Load和屏障后Load不会重排序;注意Load不保证Load是最新的数据(我的理解是因为CPU缓存优化的原因,参考缓存存储和无效队列),但是LoadLoad屏障保证了只要thread2的vonum为true(不考虑是什么时间,怎么发生的),那么屏障后面的num的值一定不会比vonum这个版本老。
2)、StoreStore:我们看到在volatile写的前面插入一个StoreStore屏障,为什么要插入这个屏障,我们先来看下StoreStore的作用,保证屏障前的Store不会和屏障后Store重排序,其实就是写入操作的执行顺序,但是具体什么时候写入也是不确定的。其实就是保证了thread1的num的写入一定先于vonum,为什么要这么做了,其实是为了保护volatile的读语义;假如我们可以重排序,vonum先执行,如果此时thread2执行,volatile的vonum已经有值,但是num还没有值,此时就会出现问题。但是如果没有重排序,num一定先于vonum写入,那么可以保证LoadLoad屏障的语义,vonum为true时,num肯定有值。
3)、LoadStore:在volatile读的后面也插入LoadStore屏障,结合上面第5点,书上说是禁止下面的普通写重排序(其实我想到的是为什么不用禁止volatile写了,我觉得和StoreLoad屏障有关系,详见下面的StoreLoad屏障),这是为什么了,我个人理解也是为了保证上面LoadLoad屏障的语义,因为如果下面的普通写和上面的volatile读和普通读重排序,那么我们读到的普通读是和volatile读那个版本的读还是普通写的读了,肯定是普通写的读,那么其实就破坏了LoadLoad屏障的语义了,普通读可能是比volatile读旧的版本,所以要禁止和普通写的重排序。
4)、StoreLoad:在volatile写的后面插入StoreLoad屏障,结合前面的1,2点Store和Load发生的时间都是不确定的,而我们知道volatile是保证可见性的。所以StoreLoad的作用是防止屏障前面的所有写和屏障后面的所有读重排序,屏障保证了前面的所有Store对所有处理器可见,屏障保证了后面的所有读都是前面Store的最新数据。其实StoreLoad屏障就是为了解决1.2点Stoe和Load的时机问题,但是它的代价要比其它几个屏障要高(底层是基于lock指令实现),相当于一个全屏障。
7、总结
要理解volatile关键字的实现原理,我觉得先得了解硬件的内存模型(顺便了解下协议),然后知道JMM,然后知道JMM为了实现可见性提供的内存屏障:LoadLoad、LoadStore、StoreStore、StoreLoad,它们每一个是什么意思,组合一起又是什么意思,了解它们的通信机制,知道volatile关键字的用途。
参考文章:
内存屏障(英文)
内存屏障(中文)