java多线程——volatile

这是java多线程第三篇:

《java 多线程—线程怎么来的》

《java多线程-内存模型》

上一篇《java多线程—内存模型》已经讲解了java线程中三特征以及happens-before 原则，这一篇主要讲解一下volatile的原理以及应用，想必看完这一篇以后，你会对volatile的应用原理以及使用边界会有更深入的认知。本篇主要内容：

1. volatile 读写同步原理
2. volatile重排序原则
3. volatile应用

 

关键字volatile是jvm提供的轻量级的同步机制，但它并不容易理解，并且在多数状况下用不到，被多数开发者抛弃并采用synchronized代替，synchronized属于重度锁，若是你对性能有高的要求，那么同等状况下，变量声明volatile会减少更少的同步开销。

在介绍以前，咱们先抛出2个问题：

一、volatile到底是如何保证共享变量的同步的？

二、i++操做为什么对虚拟机来讲不是原子操做？

 

1、volatile 读写同步原理

 

对变量进行volatile声明之后，会有如下特征:

一、可见性。  保证此变量对全部线程是可见的。

二、原子性 。只对任意单个volatile变量的读/写具备原子性（注意不是全部）。

三、有序性。被volatile声明过的变量会禁止指令重排序优化

 

happen-before 保证可见性

volatile变量的写-读能够实现线程之间的通讯。happens-before是java内存模型向咱们提供的内存可见性保证，这也就是咱们第一个问题的解答，volatiel如何保证对共享变量同步的。

咱们先回忆一下happens-before原则（咱们只说和其相关的）：

程序次序法则：若是在程序中，全部动做 A 出如今动做 B 以前，则线程中的每动做 A 都 happens-before 于该线程中的每个动做 B。

Volatile 变量法则：对 Volatile 域的写入操做 happens-before 于每一个后续对同一 Volatile 的读操做。

传递性：若是 A happens-before 于 B，且 B happens-before C，则 A happens-before C。

咱们经过一个示例来讲明这些规则的应用:

public class VolatileTest {

    private int a =0;

    private volatile int b=0;


    public void write(){

        a = 1;          //1

        b = 2;          //2

    }

    public void read(){

        int i = b;          //3

        int j = a;          //4

    }

}

好比如今有线程A和B,分别调取write和read方法。

 

第一种状况:

线程A先执行write方法以后，线程B执行read方法。那么:

一、基于程序次序法则。1 happens-before 2; 3 happens-before 4

二、基于volatile原则。2 happens-before 3；

三、基于传递性原则。由于 1 happens-before 2，2 happens-before 3，3 happens-before 4。那么能够推断出 1 happens-before 4,2 happens-before 4。

此种状况下，咱们能够认定此时线程B中能够读取到 线程A中写入的 a和b的值的。（a值没用声明volatile依然能够读取到，这个为什么咱们后面讲）

 

第二种状况:

线程B先执行read方法，以后线程A执行write方法。

一、基于程序次序法则。3 happens-before 4; 1 happens-before 2

二、基于volatile原则。无；

三、基于传递性原则。无传递；

此种状况下，咱们能够此时认定线程B中没有读取到线程A中写入的a和b的值。

 

经过上面的分析咱们能够对volatiel变量如此定义:

•  当write一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存。
•  当read一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。

对于第一种状况，咱们看上述示例如何write和read的：

那么读到这里，有一个困惑：上述变量a并无声明为volatile ，为什么能被刷新到主内存中，难道不会被处理器重排序么？

 

2、volatile限制重排序

 

上述中咱们讲到volatile 中有一个特性，有序性，防止jvm对其重排序，那么到底是如何作的，咱们看一下。

重排序分为编译器重排序和处理器重排序。为了实现volatile内存语义，jvm会分别限制这两种类型的重排序类型。

编译器重排序

针对编译器制定的volatile重排序规则:

第一个操做	第二个操做
	普通读/写	volatile读	volatile写
普通读/写			NO
volatile读	NO	NO	NO
volatile写		NO	NO

上述表中，NO表示jvm不能够重排序，保持当前顺序。

好比第一行第三列中表示：第一个操做是变量的普通读写，第二个操做是volatile声明的变量写操做，那么此时对于操做1和操做2是不能够重排序的，保持当前顺序。

就比如上述示例中a 和b变量，知足此种状况，a和b的操做顺序不变。

上述规则用文字描述:

• 当第二个操做是volatile写时，无论第一个操做是什么，都不能重排序。这个规则确保volatile写以前的操做不会被编译器重排序到volatile写以后。
• 当第一个操做是volatile读时，无论第二个操做是什么，都不能重排序。这个规则确保volatile读以后的操做不会被编译器重排序到volatile读以前。
• 当第一个操做是volatile写，第二个操做是volatile读时，不能重排序。

注意，jvm只保证2个操做保持如此规则，不能延伸到2个以上的操做上。

 

处理器重排序

为了实现上述规则，jvm编译器在生成字节码的时候，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。

在每一个volatile写操做的前面插入一个StoreStore屏障。
在每一个volatile写操做的后面插入一个StoreLoad屏障。
在每一个volatile读操做的前面插入一个LoadLoad屏障。
在每一个volatile读操做的后面插入一个LoadStore屏障。

如此能够保证在任意处理器平台，任意的程序中都能获得正确的volatile重排序规则实现。

总结

volatile防止重排序，有什么做用？

happens-before是java内存模型向咱们提供的内存可见性保证；而volatile的禁止重排序规则，包括volatile的编译器重排序规则和volatile的内存屏障插入策略，是jvm用来实现happens-before的方式。

好比上述程序中，根据happens-before的程序顺序规则：1 happens-before 2 ；3 happens-before 4.

然后根据volatile规则：2 happens-before 3. 如此操做 一、二、三、4的顺序得以延续。

也就是说volatile的禁止重排序规则，确保上述happens-before顺序。

 

3、应用

i++ 不是原子

上述原理介绍中，咱们有说volatile只对只对任意单个volatile变量的读/写具备原子性，好比变量a的赋值操做，能够为原子的，但变量a++不为原子的，咱们看个示例:

public class Test {

    private volatile  int count;

    public void increCount(){

        count++;
    }

    public void setCount(int count ){

        this.count=count;
    }

}

咱们用javap 看下increCount的编译指令：

我看红色圈中的部分，increCount被分解了4个指令来操做，而 setCount只有1个指令来处理（原子的）。咱们用代码的方式，increCount方法能够等价于如下：

    public void increCount(){

//        count++;
        int tmp =getCount();
        tmp=tmp+1;
        setCount(tmp);
    }

因此说volatile只对只对任意单个volatile变量的读/写具备原子性,而i++实际上它是一个由读取－修改－写入操做序列组成的组合操做，属于多个操做，因此不具有原子性。

 

volatile 应用原则

要使 volatile 变量提供理想的线程安全，必须同时知足下面两个条件：

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

也就是说被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。

所以只有在状态真正独立于程序内其余内容时才能使用 volatile —— 这条规则可以避免将这些模式扩展到不安全的用例。

 

应用示例

 

一、赋值操做

上述 increCount中属于依赖当前count值的应用了，而setCount属于没有依赖当前值。因此后者属于线程安全。

 

二、线程取消

对一个线程取消或者中断的时候，有人会采用interrupted方法来中断，若是维护一个volatile变量来为什么，不管外部线程如何调用，总能保证对当前线程的当即可见性。

public class  CancleThread implements Runnable{

    private volatile  boolean cancle = false;

    public void shutdown(){

        this.cancle=true;
    }

   

    public void run() {

        while (!cancle){

            //.....doSomeThing
        }

    }

}

当想终止这个线程的操做的时候，调用shutdown方法会比较安全。

 

经过以上原理和应用介绍，想必对于volatile不会那么陌生了，掌握原理，了解使用边界，让你的程序性能更高，可读性更强。咱们若是严格遵循 volatile 的使用条件 —— 即变量真正独立于其余变量和本身之前的值 —— 在某些状况下可使用 volatile 代替 synchronized 来简化代码。

 

-----------------------------------------------------------------------------

想看更多有趣原创的技术文章，扫描关注公众号。

关注我的成长和游戏研发，推进国内游戏社区的成长与进步。