你真的会用volatile吗

2020/02/09

[toc]

volatile的概念

或者说,volatile解决什么问题?

我自己的总结:volatile解决多线程下变量访问的内存可见性问题,用于线程间通信。

通信怎能理解呢,线程A写一个volatile变量,随后线程B读这个volatile变量,这个过程实质上是线程A通过 主内存向线程B发送消息。

java语言标准规范对volatile的描述是这样的:

The Java programming language allows threads to access shared variables (§17.1). As a rule, to ensure that shared variables are consistently and reliably updated, a thread should ensure that it has exclusive use of such variables by obtaining a lock that, conventionally, enforces mutual exclusion for those shared variables.

The Java programming language provides a second mechanism, volatile fields, that is more convenient than locking for some purposes.

A field may be declared volatile, in which case the Java Memory Model ensures that all threads see a consistent value for the variable (§17.4).

上面这段话摘自这个链接,有兴趣的可以自己点开看。

https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.3.1.4

大概意思是,java语言允许多个线程访问共享变量。为了保证共享变量能准确一致的更新,线程要保证通过锁的机制单独获得这个变量。java提供了一种机制,允许你把变量定义成volatile,在某些情况下比直接用锁更加方便。

如果一个变量被定义成volatile,java内存模型确保所有线程看到的这个共享变量是一致的。

这个一致怎么理解呢?继续往下看。

volatile详解

先来看一幅图,

这是一幅计算的内存架构图。

现在的CPU大部分都是多核的,在计算机内部,变量读写的流程是这样的:

  • 当一个处理器需要读取变量的时候,首先会把变量从主内存读到缓存,也有可能是寄存器,然后再做各种计算。
  • 计算的结果由寄存器刷新到缓存,然后再由缓存刷新到主内存。
  • 一个处理器的缓存回写到内存会导致其他处理器的缓存无效,这样其它处理器

这里的一个关键点是,什么时候刷新?答案是不知道。我们不能假设CPU什么时候会刷新。这样就会带来一些问题,比如一个线程写完一个共享变量,还没有刷新到主内存。然后另一个线程读这个变量还是旧的值,在很多场景下,这个结果和程序员期望的并不一致。

幸运的是,我们虽然不知道CPU什么时候刷新,但是我们可以强制CPU执行刷新。

再来看一个图,这是JAVA的内存模型图。

本地内存是JVM里一个抽象的概念,它可以涵盖寄存器,缓存等。

我们把这两幅图对应起来,可以这样解释。

在JAVA中,当一个线程写变量时,会先把这个变量从主内存拷贝一份线程的本地内存,然后在本地内存操作。操作完成之后,再刷新到主内存。只有刷新后,另一个线程才能读取新的值。

来看个例子:

public class VolatileTest implements Runnable {
    private boolean running = true;

    @Override
    public void run() {
        if (running) {
            System.out.println("I am running");
        }
    }

    public void stop() {
        running = false;
    }
}

这段代码在多线程环境下执行的时候,假设A线程正在执行run方法,B线程执行了stop方法,我们的程序没法保证A线程什么时候会马上停止。因为这取决于CPU什么时候进行刷新,把最新变量的值同步到主内存。

解决方法是,把running这个共享变量用volatile修饰即可,这样可以保证B线程的修改会立刻刷新到主内存,对其它线程可见。

public class VolatileTest implements Runnable {
    private volatile boolean running = true;

再来看个稍微复杂一点的例子。

public class VolatileTest {
    public volatile int a = 0;
    volatile boolean flag = false;

    public void write() {
        a = 1; // 位置1
        flag = true; //// 位置2
    }
    public void read() {
        if (flag) { // 位置3
            int i = a; // 位置4
        }
    }
}

Java规范对于volatile变量规则是:对一个volatile域的写,happens-before于任意后续对这个volatile域的 读。

假设线程A执行writer()方法之后,线程B执行reader()方法。根据volatile变量的happens-before规则,位置2必然先于位置3执行。同时我们知道在同一个线程中,所有操作必须按照程序的顺序来执行,所以位置1肯定早于位置2,位置3早于位置4。然后我们能推出位置1早于位置4。

这样的顺序是符合我们预期的。

这里A线程写一个volatile变量后,B线程读同一个volatile变量。A线程在写volatile变量之 前所有可见的共享变量,在B线程读同一个volatile变量后,将立即变得对B线程可见。

什么时候需要使用volatile

通过上面的例子,我们可以总结下volatile的使用场景。

通常是,存在一个或者多个共享变量,会有线程对他们写操作,也会有其它线程对他们读操作。这样的变量都应该使用volatile修饰。

volatile在标准库里的应用

ConcurrentHashMap里用到了一些volatile的操作,比如:

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;

        Node(int hash, K key, V val, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.val = val;
            this.next = next;
        }
        ...

可以看到,用于存储值的value变量就是volatile类型,这样可以保证在多线程读取的时候,不会读到过期的值。之所以不会读到过期的值,是因为根据Java内存模型的happen before原则,对volatile字段的写入操作先于读操作,即使两个线程同时修改和获取volatile变量,get操作也能拿到最新的值,这是用volatile替换锁的经典应用场景。

volatile会降低程序执行的效率

不要过度使用volatile,不必要的场景没有必要用volatile修饰变量,尽管这样做程序也不会出什么错。

根据前面的描述,volatile相当于给变量的操作加了“锁”,每次操作都有加锁和释放锁的动作,效率自然会受影响。

volatile不是万能的

对volatile经常有一中误解就是,它可以保证原子操作。

通过上面的例子,我们知道,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(() -> {
                for(int j=0;j<1000;j++)
                    test.increase();
            }).start();
        }
        while(Thread.activeCount()>2)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

执行这段代码,会发现结果每次一般都不同,但是肯定都小于10*1000。这就是volatile不保证原子性的最好证据。那么深层次的原因是什么呢?

事实上,自增操作包括三个步骤:

  1. 读取变量的原始值
  2. 进行加1操作
  3. 写入线程工作内存

既然分了三个步骤,就有可能出现下面这种情况:

假如某个时刻变量inc的值为10。

第一步,线程1对变量进行自增操作,线程1先读取了变量inc的原始值,然后线程1被阻塞了;

第二步, 然后线程2对变量进行自增操作,线程2也去读取变量inc的原始值,由于线程1只是对变量inc进行读取操作,而没有对变量进行修改操作,所以不会导致线程2会直接去主存读取inc的值,此时inc的值时10;

第三步, 线程2进行加1操作,并把11写入工作内存,最后写入主存。

第四步,线程1接着进行加1操作,由于已经读取了inc的值,此时在线程1的工作内存中inc的值仍然为10,所以线程1对inc进行加1操作后inc的值为11,然后将11写入工作内存,最后写入主存。

最后,两个线程分别进行了一次自增操作后,但是inc只增加了1。

有很多人会在第三步和第四步那里有疑问,线程2更新inc的值以后,不是会导致线程1工作内存中的值失效吗?

答案是不会,因为在一个操作中,值只会读取一次。这个是原子性和可见性区分的核心。

解决方案是使用increase方法使用synchronized同步锁修饰。具体不展开了。


参考:

  • 《java并发编程的艺术》
  • https://www.cnblogs.com/dolphin0520/p/3920373.html


欢迎关注我的公众号

(转载本站文章请注明作者和出处 犀牛饲养员

Show Disqus Comments

Post Directory