先了解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)的错误值。