多线程之 Volatile 变量 详解

时间：2023-03-09 19:25:48
多线程之 Volatile 变量 详解

Java 理论与实践: 正确使用 Volatile 变量

原文：http://www.ibm.com/developerworks/cn/java/j-jtp06197.html

总结：

volatile变量自身具有下列特性：

  • 可见性。对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。
  • 原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性。

锁提供了两种主要特性：互斥（mutual exclusion） 和可见性（visibility）。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。

Volatile 变量

Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性（是指对I++这样的符合操作来说，对于某个值的单个操作，例如实例化和为long类型赋值，具有原子特性，即不会将指令重新排序）。这就是说线程能够自动发现 volatile 变量的最新值。Volatile 变量可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或者某个变量的当前值与修改后值之间没有约束。因此，单独使用 volatile 还不足以实现计数器、互斥锁或任何具有与多个变量相关的不变式（Invariants）的类（例如 “start <=end”）。

正确使用 volatile 变量的条件

您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

  • 对变量的写操作不依赖于当前值。  （例如 I++）
  • 该变量没有包含在具有其他变量的不变式中。 （例如 下界总是小于或等于上界）

举例说明：

第一个条件的限制使 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 类型是无法实现这一目的的。

正确使用 volatile 的模式

原则：要始终牢记使用 volatile 的限制 —— 只有在状态真正独立于程序内其他内容时才能使用 volatile —— 这条规则能够避免将这些模式扩展到不安全的用例。

正确用例1：（可见性特性）

实现 volatile 变量的规范使用仅仅是使用一个布尔状态标志

volatile boolean shutdownRequested;

...

public void shutdown() { shutdownRequested = true; }

public void doWork() {

    while (!shutdownRequested) {

        // do stuff

    }

}

正确用例2：（不重排序特性）

线程安全的单例模式

  1. public class SingletonKerriganD {
  2. /**
  3. * 单例对象实例
  4. */
  5. private static SingletonKerriganD instance = null;
  6. public static SingletonKerriganD getInstance() {
  7. if (instance == null) {
  8. synchronized (SingletonKerriganD.class) {
  9. if (instance == null) {
  10. instance = new SingletonKerriganD();
  11. }
  12. }
  13. }
  14. return instance;
  15. }
  16. }

其他用例看原文。

正确用例3（高级）：开销较低的读写锁策略。（volatile 的开销比synchronized 小，而且volatile 读操作，更小，其不包含所操作，几乎等于非volatile读）

如果读操作远远超过写操作，您可以结合使用内部锁和 volatile 变量来减少公共代码路径的开销。清单 6 中显示的线程安全的计数器使用synchronized 确保增量操作是原子的，并使用 volatile 保证当前结果的可见性。如果更新不频繁的话，该方法可实现更好的性能，因为读路径的开销仅仅涉及 volatile 读操作，这通常要优于一个无竞争的锁获取的开销。

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++;

    }

}
相关文章