深入理解java多线程—volatile

阅读 288
收藏 32
2017-09-06
原文链接:mp.weixin.qq.com

这是java多线程系列第三篇:

java 多线程—线程怎么来的?

java多线程-内存模型

上一篇《java多线程—内存模型》已经讲解了java线程中三特征以及happens-before 原则,这一篇主要讲解一下volatile的原理以及应用。

本篇主要内容:

volatile 读写同步原理

volatile重排序原则

volatile应用

关键字volatile是jvm提供的轻量级的同步机制,但它并不容易理解,而且多数开发者会抛弃它直接采用synchronized来代替。

synchronized属于重度锁,如果你对性能有高的要求,那么同等情况下,变量声明volatile会减小更少的同步开销。

在介绍之前,我们先抛出2个问题:

1、volatile究竟是如何保证共享变量的同步的?

2、i++操作为何对虚拟机来说不是原子操作?

1
volatile 读写同步原理

对变量进行volatile声明以后,会有以下特征:

1、可见性。  保证此变量对所有线程是可见的。

2、原子性 。只对任意单个volatile变量的读/写具有原子性(注意不是所有)。

3、有序性。被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 = a;          //3

        int j = b;          //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 ,为何能被刷新到主内存中,难道不会被处理器重排序么?

上述中我们讲到volatile 中有一个特性,有序性,防止jvm对其重排序,那么究竟是如何做的,我们看一下。 

2
volatile重排序规则

重排序分为编译器重排序和处理器重排序。为了实现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. 如此操作 1、2、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 变量提供理想的线程安全,必须同时满足下面两个条件:

  1. 对变量的写操作不依赖于当前值。

  2. 该变量没有包含在具有其他变量的不变式中。

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

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

4
应用示例
1、赋值操作

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

2、线程取消

对一个线程取消或者中断的时候,有人会采用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 来简化代码,并节省性能开销。

end
只做原创游戏内容,助力国内游戏社区的成长与进步。

扫描关注更多

评论