稀有猿诉

十年磨一剑,历炼出锋芒,说话千百句,不如码二行。

理解Java关键字volatile

在Java中,关键字volatile是除同步锁以外,另一个同步机制,它使用起来比锁要简单方便,但是却很容易被忽略,或者被误用。这篇文章就来详细讲解一下volatile它的作用,它的原理以及如何正确的使用它。

volatile的定义

这个引用JSR中的定义:

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).

简单的翻译一下:

Java编程语言中允许线程访问共享变量。为了确保共享变量能被一致地和可靠的更新,线程必须确保它是排他性的使用此共享变量,通常都是获得对这些共享变量强制排他性的同步锁。

Java编程语言提供了另一种机制,volatile域变量,对于某些场景的使用这要更加的方便。

可以把变量声明为volatile,以让Java内存模型来保证所有线程都能看到这个变量的同一个值。

volatile的作用

  • 保证变量的可见性

    volatile关键字的作用就是保证共享变量的可见性。什么是可见性呢,就是一个线程读变量,总是能读到它在内存中的最新的值,也就是说不同的线程看到的一个变量的值是相同的。CPU都是有行缓存的,volatile能让行缓存无效,因此能读到内存中最新的值。

  • 保证赋值操作的原子性

    原子性就是不能被线程调度打断的操作,是线程安全的操作,对于原子性操作,即使在多线程环境下,也不用担心线程安全问题或者数据不一致的问题。有些变量的赋值本身就是原子性的,比如对boolean,对int的赋值,但是像对于long或者double则不一定,如果是32位的处理器,对于64位的变量的操作可能会被分解成为二个步骤:高32位和低32位,由此可能会发生线程切换,从而导致线程不安全。如果变量声明为volatile,那么虚拟机会保证赋值是原子的,是不可被打断的。

  • 禁止指令重排

    正常情况下,虚拟机会对指令进行重排,当然是在不影响程序结果的正确性的前提下。volatile能够在一定程度上禁止虚拟机进行指令重排。还有就是对于volatile变量的写操作,保证是在读操作之前完成,假设线程A来读变量,刚好线程B正在写变量,那么虚拟机会保证写在读之前完成。 比如:

1
2
3
4
5
6
7
8
9
private volatile boolean flag;
  
public void setFlag(boolean flag) {
  this.flag = flag;
}
  
public void getFlag() {
  return flag;
}

假设线程A来调用setFlag(true),线程B同时来调用getFlag,对于一般的变量,是无法保证B能读到A设置的值的,因为它们执行的顺序是未知的。但是像上面,加上volatile修饰以后,虚拟机会保证,线程A的写操作在线程B的读操作之前完成,换句话,B能读到最新的值。当然了,用锁机制也能达到同样的效果,比如在方法前面都加上synchronized关键字,但是性能会远不如使用volatile。

volatile的典型使用场景

多线程情况下的标志位

基于它的作用,不难找到使用它的理想场景:

  • 读操作,多于写操作
  • 写操作,不依赖于变量的当前值,也就是说要是纯赋值操作
  • 只需要读取的值,不需要等待某一特定的值

比如,有一个检查新版本的按扭,点击时会发起去检查新版本,因为检查新版本涉及网络请求,可能会比较耗时,所以需要放在单独的线程中去做。为了避免多次同时触发检查请求,做一个限制:上一个请求没有完成时,再次点击无效。这时就可以用volatile来做个标志位,伪代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private volatile boolean checkUpdateFinished = true;

public void onCheckUpdate(View view) {
    if (!checkUpdateFinished) {
        return;
    }
    checkUpdate();
}

private void checkUpdate() {
    checkUpdateFinished = false;
    new Thread(new Runnable() {
      @Override
      public void run() {
          doCheckUpdate();
          checkUpdateFinished = true;
      }
    }).start();
}

CAS无锁同步的变量声明

CAS(Compare And Swap)是一种无锁同步的算法,它涉及变量的3个值,当前值,旧的期望值以及新的期望值,它的原理是当且仅当当前值与旧的期望值一致时,才把新值赋给变量,否则什么都不做:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private volatile int a;

do {
   old = 3;
   expected = 5;
} while (compareAndSwap(a, 3, 5);

boolean compareAndSwap(int a, int old, int expected) {
  if (a == old) {
      a = expected;
      return true;
  }
  return false;
}

当然,具体的compare and swap不是这么实现的,实际是要直接使用处理的指令CMPXCHG(Compare and Exchange)来做具体的CAS。 为了保证可见性,CAS中的变量必须都用volatile来修饰。

volatile的内存原理

知道了volatile有什么用,怎么用以后,可以了解的更深一点,以加深理解。但要搞懂,就必须先要搞懂它的背景以及背景的背景:

并发的基本概念

  • 原子性

    一个或者多个操作(赋值也好,运算也好)不能被线程调度打断,要么一次性执行完,要么就不执行。

  • 可见性

    现代处理器是多核心的,或者多CPU的,但是主存(通常意义上的操作系统内存,或者物理内存)却是在CPU之间共享的。多核心处理的优势在于,从机器级别支持多线程并发,而且为了弥补主存与CPU核心之间的速度差异,便有了CPU核心缓存,因此,每个CPU核心(或者说每个线程)是有独立的内存的。这样就带来了可见性的问题,同一个变量c,A线程操作的是c在A线程的缓存中的值,B操作的是c在B的缓存中值,也就是说最新的变量的值对于其他线程是不可见的,这就有了可见性的问题。

  • 有序性

    对于单线程来说,程序的执行顺序就是按照代码的书写顺序,从上到下,从左到右(分号分隔写在同一行时)。但是多线程情况就不一定了,线程调度器随时可能打断某一程,执行其他线程。这就导致了,程序并不是按照预期的顺序执行的,导致结果跟预期不一致。 注意:这里的顺序,并不是严格的指令执行的顺序,而且从结果正确性的角度来看的,比如:

1
2
  int a = 10;
  int b = a + 1;

这段代码的有序性的意思是:当执行到第二条语句,只要a的值是10就可以了,至于a = 10它究竟是否是在下面语句前执行,并不关心。但是,除了a = 10语句外,没有其他的方式能让a变成10,所以,肯定是执行了语句了才能把a变成10。说起来比较绕,这个例子也过于简单。但是可以这么简单的理解为:单线程情况下,程序是按书写的顺序来执行的,更准确的说法是程序员预期的顺序来执行的。但多线程会打破这种有序性。

注意:这里我们不考虑ABA问题

内存模型的基本概念

对内存模型的理解

什么是内存模型呢?就是程序运行起来时,内存里面的样子。程序包括变量,对象,数据,指令等,程序动起来后又包括变量如何赋值,数据如何读取,指令按什么顺序执行等。其实,程序运行时,内存是什么样子,通常取决于操作系统,也就是说是由操作系统决定的。Java是跨平台的语言,其靠着“Compile once, run anywhere”的大旗,拮杆而起,打下一片天下,如今稳坐头把交椅。那么,想要跨平台,它就要屏蔽各个操作系统平台和硬件平台的差异,因此它有虚拟机,虚拟机实质是一对操作系统的一个抽象,把差异进行屏蔽,从而对语言本身来说,所有操作系统就都是一样的了。内存模型,也就是虚拟机对运行时的一些约定,或者叫做强制规定,比如变量的操作,数据的读取,指令执行顺序等。都做了哪些规定呢?我们分别来说:

  • 线程模型

    因为Java天生支持多线程,所以,虚拟机也必须要有线程模型,否则就无法屏蔽操作系统的差异。虚拟机规定,所有的变量都存储在主存中,也就是通常所指的内存,每个线程可以有自己的独立的工作内存,可以理解为每个CPU核心的缓存,线程对变量的操作都只能在自己的工作内存中,不能直接对主存操作,也不能访问其他线程的工作内存。

  • 原子性操作

    虚拟机保证对基本的基本数据类型的赋值是原子的,比如int,boolean和float。但是像long和double不一定,这取决于CPU的字长,32位下,long和double的赋值不是原子的,因为需要二个指令;而64位CPU则一个指令搞定。

    如何保证原子性呢?方式一是上面提过的用volatile,另外就是用同步锁机制。

  • 可见性

    前面说到每个CPU可以有自己的工作内存,因此,当一个线程对某一变量操作后,其他线程是没有办法直接拿到最新变化的。

    如何保证可见性呢?方法一就是把变量用volatile修饰,另外就是用同步锁机制。

  • 指令重排与happens-before原则

    指令重排与happens-before原因,是不同的,也是不冲突的。正常情况下,也就是说单线程情况下,指令的执行顺序是按书写顺序从上到下,但不是严格的,虚拟机会在不影响程序结果正确性的前提下对指令进行重排,比如:

1
2
3
int a = 1;
int b = 2;
int c = 3;

这三个指令,哪个先执行,是不会影响程序结果的,这时指令可能重排;而再如:

1
2
3
int a = 1;
int b = a + 1;
int c = a + b;

这种情况下,是无法重排,不可能把第3句放到前面,那样会得不到正确的结果。

而happens-before是指在多线程情况下,虚拟机来保证某些操作的先后性,或者说前面的操作结果,对后面是可见的。比如上面的第二个例子,在多线程情况下,c = a + b是有可能在a, b赋值前执行的,这也恰 恰是我们需要小心解决的由多线程机制带来的问题。

虚拟机的默认支持的happens-before(先行发生)原则:

  • 程序次序规则:一个线程内,按照代码顺序,书写在前面的操作先行发生于书写在后面的操作
  • 锁定规则:一个unLock操作先行发生于后面对同一个锁额lock操作
  • volatile变量规则:对一个变量的写操作先行发生于后面对这个变量的读操作
  • 传递规则:如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出操作A先行发生于操作C
  • 线程启动规则:Thread对象的start()方法先行发生于此线程的每个一个动作
  • 线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
  • 线程终结规则:线程中所有的操作都先行发生于线程的终止检测,我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
  • 对象终结规则:一个对象的初始化完成先行发生于他的finalize()方法的开始

很多规则显而易见的,或者想一下还是很容易想通的,重点解析一下第2, 3, 4条:

  • 锁定规则:一个unLock操作先行发生于后面对同一个锁额lock操作

    这里的意思是,同一个锁(lock),如果处于锁定状态,那么只能先释放锁,然后才能被再次锁定。这么一说就明白了,这是显而易见的,要不然锁不就失去它本身的作用了么。

    注意:这里有必要进一步说明一下,对于可重入锁,这里应该指的就是其他线程再次获得锁之前,锁必须被释放。因为对于可重入锁,锁的持有线程,是可以在不释放的前提下,继续获得锁的。

  • volatile变量规则:对一个变量的写操作先行发生于后面对这个变量的读操作

    这里其实有二层,一个是前面提过的,读volatile总是能读到最新的值,即使是写线程和读线程同时进行。因为,写操作会被更新到主存,读线程的工作内存会被置为无效,需要重新到主存去读,而读主存的地址,是要等待该地址更新后才能成功读取。

    另外,一个就是对于volatile上下文的变量的读写的影响,也就是说它为什么能禁止指令重排:volatile的准确可见性作用是,当一个线程写一个volatile变量时,写完成后会刷新工作内存到主存,这会把目前这个线程所做过修改的所有变量都刷新到主存。举个例子来说明:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int a;
int b;
volatile boolean flag;
          
void write() {
  a = 3;
  b = 4;
  flag = true;
}
          
void read() {
  print(a);
  print(b);
  print(flag);
}

如果线程A调用write(),线程B调用read(),那么B能读到a, b和flag的最新值(A所写的值)。

由此,可以引申出一个volatile的高级应用,可以当作同步锁:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private Object object = null;
private volatile hasNewObject = false;
          
public void put(Object newObject) {
    while (hasNewObject) {
       //wait - do not overwrite existing new object
    }
    object = newObject;
    hasNewObject = true; //volatile write
}
          
public Object take() {
  while (!hasNewObject) { //volatile read
      //wait - don't take old object (or null)
  }
  Object obj = object;
  hasNewObject = false; //volatile write
  return obj;
}

因为写hasNewObject时会把object也刷新了,所以取对象的线程,可以在只要hasNewObject为true时就可以读到正确的值。 * 传递规则:如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出操作A先行发生

这个就像某些运行符的传递性一样,具体传递性,从而使整个happens-before规则产生实际作用。

volatile的实现机制

计算机科学里面,为了解决复杂性,都会分层。正如一个名人所说:”计算机的任何问题都可以通过增加一个虚拟层来解决”(“All problems in computer science can be solved by another level of indirection”)。volatile虚拟机层引入的,解决语言层面的问题,那么它的实现,必然是靠下一层的支持,也就是需要汇编或者说处理器指令的支持来实现,volatile是靠内存屏障和MESI(缓存一致性协议)来达成的它的作用的。

内存屏障(Memory Barriers)是处理器提供的一组内存操作指令,它的作用是限制内存操作的顺序,也就是说内存屏障像一个栅栏一样,它前面的指令要在它后面的指令之前完成;还能强制把缓存写入到主存;再有的就是触发缓存一致性,就是当有写变量时,会把其他CPU核心的缓存变为无效。

总结

volatile是一个比较复杂的修饰符,想要使用它,就要完全理解它的作用,它能用来做什么,以及不能干什么。如果,不是很确定,要么弄懂,要么就不要使用。事实上,大多数情况下,标志变量,还是非常适合volatile的。

java.util.concurrent.*里面的高级线程安全数据结构像ConcurrentHashMap以及java.util.concurrent.atomic.*等的实现都用到了volatile。可以多看看这些类的实现,以加深对volatile的理解和运用。

参考资料

Comments