副标题#e#
Java 语言中的 volatile 变量可以被看作是一种 “水平较轻的 synchronized”；与 synchronized 块对比，volatile 变量所需的编码较少，而且运行时开销也较少，可是它所能实现的成果也仅是 synchronized 的一部门。本文先容了几种有效利用 volatile 变量的模式，并强调了几种不适合利用 volatile 变量的景象。
锁提供了两种主要特性：互斥（mutual exclusion） 和可见性（visibility）。互斥即一次只答允一个线程持有某个特定的锁，因此可利用该特性实现对共享数据的协调会见协议，这样，一次就只有一个线程可以或许利用该共享数据。可见性要越发巨大一些，它必需确保释放锁之前对共享数据做出的变动对付随后得到该锁的另一个线程是可见的 —— 假如没有同步机制提供的这种可见性担保，线程看到的共享变量大概是修改前的值或纷歧致的值，这将激发很多严重问题。
Volatile 变量
Volatile 变量具有 synchronized 的可见性特性，可是不具备原子特性。这就是说线程可以或许自动发明 volatile 变量的最新值。Volatile 变量可用于提供线程安详，可是只能应用于很是有限的一组用例：多个变量之间可能某个变量的当前值与修改后值之间没有约束。因此，单独利用 volatile 还不敷以实现计数器、互斥锁或任何具有与多个变量相关的稳定式（Invariants）的类（譬喻 “start <=end”）。
出于浅易性或可伸缩性的思量，您大概倾向于利用 volatile 变量而不是锁。当利用 volatile 变量而非锁时，某些习习用法（idiom）越发易于编码和阅读。另外，volatile 变量不会像锁那样造成线程阻塞，因此也很少造成可伸缩性问题。在某些环境下，假如读操纵远远大于写操纵，volatile 变量还可以提供优于锁的机能优势。
正确利用 volatile 变量的条件
您只能在有限的一些景象下利用 volatile 变量替代锁。要使 volatile 变量提供抱负的线程安详，必需同时满意下面两个条件：
对变量的写操纵不依赖于当前值。
该变量没有包括在具有其他变量的稳定式中。
实际上，这些条件表白，可以被写入 volatile 变量的这些有效值独立于任何措施的状态，包罗变量的当前状态。
第一个条件的限制使 volatile 变量不能用作线程安详计数器。固然增量操纵（x++）看上去雷同一个单独操纵，实际上它是一个由读取－修改－写入操纵序列构成的组合操纵，必需以原子方法执行，而 volatile 不能提供必需的原子特性。实现正确的操纵需要使 x 的值在操纵期间保持稳定，而 volatile 变量无法实现这点。（然而，假如将值调解为只从单个线程写入，那么可以忽略第一个条件。）
大大都编程景象城市与这两个条件的个中之一斗嘴，使得 volatile 变量不能像 synchronized 那样普遍合用于实现线程安详。清单 1 显示了一个非线程安详的数值范畴类。它包括了一个稳定式 —— 下界老是小于或便是上界。
清单 1. 非线程安详的数值范畴类
@NotThreadSafe
public class NumberRange {
private int lower, upper;
public int getLower() { return lower; }
public int getUpper() { return 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;
}
}
这种方法限制了范畴的状态变量，因此将 lower 和 upper 字段界说为 volatile 范例不可以或许充实实现类的线程安详；从而仍然需要利用同步。不然，假如凑巧两个线程在同一时间利用纷歧致的值执行 setLower 和 setUpper 的话，则会使范畴处于纷歧致的状态。譬喻，假如初始状态是 (0, 5)，同一时间内，线程 A 挪用 setLower(4) 而且线程 B 挪用 setUpper(3)，显然这两个操纵交错存入的值是不切合条件的，那么两个线程城市通过用于掩护稳定式的查抄，使得最后的范畴值是 (4, 3) —— 一个无效值。至于针对范畴的其他操纵，我们需要使 setLower() 和 setUpper() 操纵原子化 —— 而将字段界说为 volatile 范例是无法实现这一目标的。
#p#副标题#e#
机能思量
利用 volatile 变量的主要原因是其浅易性：在某些景象下，利用 volatile 变量要比利用相应的锁简朴得多。利用 volatile 变量次要原因是其机能：某些环境下，volatile 变量同步机制的机能要优于锁。
很难做出精确、全面的评价，譬喻 “X 老是比 Y 快”，尤其是对 JVM 内涵的操纵而言。（譬喻，某些环境下 VM 也许可以或许完全删除锁机制，这使得我们难以抽象地较量 volatile 和 synchronized 的开销。）就是说，在今朝大大都的处理惩罚器架构上，volatile 读操纵开销很是低 —— 险些和非 volatile 读操纵一样。而 volatile 写操纵的开销要比非 volatile 写操纵多许多，因为要担保可见性需要实现内存界定（Memory Fence），即便如此，volatile 的总开销仍然要比锁获取低。
#p#分页标题#e#
volatile 操纵不会像锁一样造成阻塞，因此，在可以或许安详利用 volatile 的环境下，volatile 可以提供一些优于锁的可伸缩特性。假如读操纵的次数要远远高出写操纵，与锁对比，volatile 变量凡是可以或许淘汰同步的机能开销。
正确利用 volatile 的模式
许多并发性专家事实上往往引导用户远离 volatile 变量，因为利用它们要比利用锁越发容易堕落。然而，假如审慎地遵循一些精采界说的模式，就可以或许在许多场所内安详地利用 volatile 变量。要始终紧记利用 volatile 的限制 —— 只有在状态真正独立于措施内其他内容时才气利用 volatile —— 这条法则可以或许制止将这些模式扩展到不安详的用例。
模式 #1：状态符号
也许实现 volatile 变量的类型利用仅仅是利用一个布尔状态符号，用于指示产生了一个重要的一次性事件，譬喻完成初始化或请求停机。
许多应用措施包括了一种节制布局，形式为 “在还没有筹备好遏制措施时再执行一些事情”，如清单 2 所示：
清单 2. 将 volatile 变量作为状态符号利用
volatile boolean shutdownRequested;
...
public void shutdown() { shutdownRequested = true; }
public void doWork() {
while (!shutdownRequested) {
// do stuff
}
}
很大概会从轮回外部挪用 shutdown() 要领 —— 即在另一个线程中 —— 因此，需要执行某种同步来确保正确实现 shutdownRequested 变量的可见性。（大概会从 JMX 侦听措施、GUI 事件线程中的操纵侦听措施、通过 RMI 、通过一个 Web 处事等挪用）。然而，利用 synchronized 块编写轮回要比利用清单 2 所示的 volatile 状态符号编写贫苦许多。由于 volatile 简化了编码，而且状态符号并不依赖于措施内任何其他状态，因此此处很是适合利用 volatile。
这种范例的状态标志的一个民众特性是：凡是只有一种状态转换；shutdownRequested 符号从 false 转换为 true，然后措施遏制。这种模式可以扩展到往返转换的状态符号，可是只有在转换周期不被察觉的环境下才气扩展（从 false 到 true，再转换到 false）。另外，还需要某些原子状态转换机制，譬喻原子变量。
模式 #2：一次性安详宣布（one-time safe publication）
缺乏同步会导致无法实现可见性，这使得确定何时写入工具引用而不是原语值变得越发坚苦。在缺乏同步的环境下，大概会碰着某个工具引用的更新值（由另一个线程写入）和该工具状态的旧值同时存在。（这就是造成著名的双重查抄锁定（double-checked-locking）问题的来源，个中工具引用在没有同步的环境下举办读操纵，发生的问题是您大概会看到一个更新的引用，可是仍然会通过该引用看到不完全结构的工具）。
实现安详宣布工具的一种技能就是将工具引用界说为 volatile 范例。清单 3 展示了一个示例，个中靠山线程在启动阶段从数据库加载一些数据。其他代码在可以或许操作这些数据时，在利用之前将查抄这些数据是否曾经宣布过。
清单 3. 将 volatile 变量用于一次性安详宣布
public class BackgroundFloobleLoader {
public volatile Flooble theFlooble;
public void initInBackground() {
// do lots of stuff
theFlooble = new Flooble(); // this is the only write to theFlooble
}
}
public class SomeOtherClass {
public void doWork() {
while (true) {
// do some stuff...
// use the Flooble, but only if it is ready
if (floobleLoader.theFlooble != null)
doSomething(floobleLoader.theFlooble);
}
}
}
假如 theFlooble 引用不是 volatile 范例，doWork() 中的代码在清除对 theFlooble 的引用时，将会获得一个不完全结构的 Flooble。
该模式的一个须要条件是：被宣布的工具必需是线程安详的，可能是有效的不行变工具（有效不行变意味着工具的状态在宣布之后永远不会被修改）。volatile 范例的引用可以确保工具的宣布形式的可见性，可是假如工具的状态在宣布后将产生变动，那么就需要特另外同步。
模式 #3：独立调查（independent observation）
安详利用 volatile 的另一种简朴模式是：按期 “宣布” 调查功效供措施内部利用。譬喻，假设有一种情况传感器可以或许感受情况温度。一个靠山线程大概会每隔几秒读取一次该传感器，并更新包括当前文档的 volatile 变量。然后，其他线程可以读取这个变量，从而随时可以或许看到最新的温度值。
#p#分页标题#e#
利用该模式的另一种应用措施就是收集措施的统计信息。清单 4 展示了身份验证机制如何影象最近一次登录的用户的名字。将重复利用 lastUser 引用来宣布值，以供措施的其他部门利用。
清单 4. 将 volatile 变量用于多个独立调查功效的宣布
public class UserManager {
public volatile String lastUser;
public boolean authenticate(String user, String password) {
boolean valid = passwordIsValid(user, password);
if (valid) {
User u = new User();
activeUsers.add(u);
lastUser = user;
}
return valid;
}
}
该模式是前面模式的扩展；将某个值宣布以在措施内的其他处所利用，可是与一次性事件的宣布差异，这是一系列独立事件。这个模式要求被宣布的值是有效不行变的 —— 即值的状态在宣布后不会变动。利用该值的代码需要清楚该值大概随时产生变革。
模式 #4：“volatile bean” 模式
volatile bean 模式合用于将 JavaBeans 作为“荣誉布局”利用的框架。在 volatile bean 模式中，JavaBean 被用作一组具有 getter 和/或 setter 要领 的独立属性的容器。volatile bean 模式的根基道理是：许多框架为易变数据的持有者（譬喻 HttpSession）提供了容器，可是放入这些容器中的工具必需是线程安详的。
在 volatile bean 模式中，JavaBean 的所有数据成员都是 volatile 范例的，而且 getter 和 setter 要领必需很是普通 —— 除了获取或配置相应的属性外，不能包括任何逻辑。另外，对付工具引用的数据成员，引用的工具必需是有效不行变的。（这将克制具有数组值的属性，因为当数组引用被声明为 volatile 时，只有引用而不是数组自己具有 volatile 语义）。对付任何 volatile 变量，稳定式或约束都不能包括 JavaBean 属性。清单 5 中的示例展示了遵守 volatile bean 模式的 JavaBean：
清单 5. 遵守 volatile bean 模式的 Person 工具
@ThreadSafe
public class Person {
private volatile String firstName;
private volatile String lastName;
private volatile int age;
public String getFirstName() { return firstName; }
public String getLastName() { return lastName; }
public int getAge() { return age; }
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public void setAge(int age) {
this.age = age;
}
}
volatile 的高级模式
前面几节先容的模式涵盖了大部门的根基用例，在这些模式中利用 volatile 很是有用而且简朴。这一节将先容一种越发高级的模式，在该模式中，volatile 将提供机能或可伸缩性优势。
volatile 应用的的高级模式很是懦弱。因此，必需对假设的条件仔细证明，而且这些模式被严格地封装了起来，因为纵然很是小的变动也会损坏您的代码！同样，利用更高级的 volatile 用例的原因是它可以或许晋升机能，确保在开始应用高级模式之前，真正确定需要实现这种机能获益。需要对这些模式举办衡量，放弃可读性或可维护性来调换大概的机能收益 —— 假如您不需要晋升机能（可能不可以或许通过一个严格的测试措施证明您需要它），那么这很大概是一次糟糕的生意业务，因为您很大概会得不偿失，换来的对象要比放弃的对象代价更低。
模式 #5：开销较低的读－写锁计策
今朝为止，您应该相识了 volatile 的成果还不敷以实现计数器。因为 ++x 实际上是三种操纵（读、添加、存储）的简朴组合，假如多个线程凑巧试图同时对 volatile 计数器执行增量操纵，那么它的更新值有大概会丢失。
然而，假如读操纵远远高出写操纵，您可以团结利用内部锁和 volatile 变量来淘汰民众代码路径的开销。清单 6 中显示的线程安详的计数器利用 synchronized 确保增量操纵是原子的，并利用 volatile 担保当前功效的可见性。假如更新不频繁的话，该要领可实现更好的机能，因为读路径的开销仅仅涉及 volatile 读操纵，这凡是要优于一个无竞争的锁获取的开销。
清单 6. 团结利用 volatile 和 synchronized 实现 “开销较低的读－写锁”
@ThreadSafe
public class CheesyCounter {
// Employs the cheap read-write lock trick
// All mutative operations MUST be done with the 'this' lock held
@GuardedBy("this") private volatile int value;
public int getValue() { return value; }
public synchronized int increment() {
return value++;
}
}
#p#分页标题#e#
之所以将这种技能称之为 “开销较低的读－写锁” 是因为您利用了差异的同步机制举办读写操纵。因为本例中的写操纵违反了利用 volatile 的第一个条件，因此不能利用 volatile 安详地实现计数器 —— 您必需利用锁。然而，您可以在读操纵中利用 volatile 确保当前值的可见性，因此可以利用锁举办所有变革的操纵，利用 volatile 举办只读操纵。个中，锁一次只答允一个线程会见值，volatile 答允多个线程执行读操纵，因此当利用 volatile 担保读代码路径时，要比利用锁执行全部代码路径得到更高的共享度 —— 就像读－写操纵一样。然而，要随时紧记这种模式的弱点：假如逾越了该模式的最根基应用，团结这两个竞争的同步机制将变得很是坚苦。
竣事语
与锁对比，Volatile 变量是一种很是简朴但同时又很是懦弱的同步机制，它在某些环境下将提供优于锁的机能和伸缩性。假如严格遵循 volatile 的利用条件 —— 即变量真正独立于其他变量和本身以前的值 —— 在某些环境下可以利用 volatile 取代 synchronized 来简化代码。然而，利用 volatile 的代码往往比利用锁的代码越发容易堕落。本文先容的模式涵盖了可以利用 volatile 取代 synchronized 的最常见的一些用例。遵循这些模式（留意利用时不要高出各自的限制）可以辅佐您安详地实现大大都用例，利用 volatile 变量得到更佳机能。
