Java中 volatile 关键字（简析）

先了解java内存模型的概念，如图：

一个变量在不同线程存在一个各自的副本（简单理解为缓冲区）

写过程：先修改变量副本，再同步到主内存。

读过程：先从主内存同步到副本，再读取副本变量。

 

问题的产生：

线程1

		boolean stop = false;
		@Override
		public void run()
		{
			while (!stop)
			{
				// TODO
			}
		}

线程2

		stop = true;

一种可能的运行情况：线程2 设置了结束标记，但是并没有同步到主内存，此时 线程1 读取到的仍然是 false，所以循环不会结束。

如果使用 volatile ：

		volatile boolean stop = false;

那么 线程2 修改标记后，会及时将值同步到主内存，这就是 volatile 最直观的作用。

 

再来看一个例子：

public class Singleton
{
	private static Singleton instance = null;

	public static Singleton getInstance()
	{
		if (instance == null)
		{
			synchronized (Singleton.class)
			{
				if (instance == null)
					instance = new Singleton();
			}
		}
		return instance;
	}
}

这个单例虽然做了双重检查，并且用了 synchronized ，但是，仍然有很小概率运行成以下结果：

线程A、线程B 都通过了第一次判空，此时 线程A 进入同步代码块创建实例并给 instance 赋值，但是因为没有使用 volatile ，修改后的 instance 并未同步到主内存，此时 线程A 让出同步锁，线程B 进入执行，因为 线程B 拿到的值仍然为空，所以 线程B 也会创建实例，至此就创建了两个实例，显然是错误的。使用 volatile 可以让 线程A 及时同步 instance 到主内存，此时 线程B 判空失败，就不会再次创建实例。

	private volatile static Singleton instance = null;

总体来说：volatile 的开销比 synchronized 要小，简单情况下可以代替 synchronized 使用。但是由于 volatile 不具有原子性，所以如下示例，可能会出错：

public class NumberRange
{
	private volatile int lower, upper;

	public NumberRange(int lower, int upper)
	{
		this.lower = lower;
		this.upper = upper;
	}

	public void setLower(int value)
	{
		if (value > upper)
			throw new IllegalArgumentException();
		lower = value;
	}

	public void setUpper(int value)
	{
		if (value < lower)
			throw new IllegalArgumentException();
		upper = value;
	}
}

以下调用可能会产生错误的结果：

		NumberRange range = new NumberRange(1, 5);
		range.setLower(4); // 线程A调用
		range.setUpper(3); // 线程B调用

因为 volatile 不具有原子性，两个线程可能都通过了判断，最终产生（4, 3）的错误值。