理解Java关键字volatile

原文链接理解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正在写变量，那么虚拟机会保证写在读之前完成。比如：

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来做个标志位，伪代码如下：

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个值，当前值，旧的期望值以及新的期望值，它的原理是当且仅当当前值与旧的期望值一致时，才把新值赋给变量，否则什么都不做：

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的缓存中值，也就是说最新的变量的值对于其他线程是不可见的，这就有了可见性的问题。
有序性

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

  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原因，是不同的，也是不冲突的。正常情况下，也就是说单线程情况下，指令的执行顺序是按书写顺序从上到下，但不是严格的，虚拟机会在不影响程序结果正确性的前提下对指令进行重排，比如：

int a = 1;
int b = 2;
int c = 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变量时，写完成后会刷新工作内存到主存，这会把目前这个线程所做过修改的所有变量都刷新到主存。举个例子来说明：

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的高级应用，可以当作同步锁：

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的理解和运用。

理解Java关键字volatile

原文链接理解Java关键字volatile

volatile的定义

volatile的作用

volatile的典型使用场景

多线程情况下的标志位

CAS无锁同步的变量声明

volatile的内存原理

并发的基本概念

对内存模型的理解

volatile的实现机制

总结

参考资料

原创不易，打赏，点赞，在看，收藏，分享总要有一个吧

理解Java关键字volatile

原文链接 理解Java关键字volatile

volatile的定义

volatile的作用

volatile的典型使用场景

多线程情况下的标志位

CAS无锁同步的变量声明

volatile的内存原理

并发的基本概念

对内存模型的理解

volatile的实现机制

总结

参考资料

原创不易，打赏，点赞，在看，收藏，分享 总要有一个吧

原文链接理解Java关键字volatile

原创不易，打赏，点赞，在看，收藏，分享总要有一个吧