理解 volatile 的非原子性：深入分析及字节码解释

在 Java 并发编程中，volatile关键字提供了一种保证变量在多线程之间可见性和有序性的机制。然而，volatile的作用经常被误解。许多开发者认为使用volatile能确保操作的线程安全性，但事实上，volatile并不保证操作的原子性。本文将深入分析volatile的局限性，并通过字节码分析进一步揭示其非原子性根源。

volatile的作用：可见性和有序性

在并发环境下，volatile修饰的变量可以确保两个特性：

可见性：每当一个线程修改了volatile变量的值，该值会立即刷新到主内存中，保证其他线程读取到的是最新值。具体来说，线程进行读操作时会直接从主内存中读取，而不是从 CPU 缓存中读取；写操作则直接刷新到主内存中。
有序性：volatile通过内存屏障（Memory Barrier）来避免指令重排序，确保volatile变量在多个线程之间的操作顺序。Java 使用happens-before规则来保证这些操作的可见性。

这两个特性使得volatile非常适用于需要通知或标记状态的变量，例如实现一个简单的“开关”功能。但在涉及复杂运算（如自增操作）时，volatile的作用有限。

volatile的局限性：无法保证原子性

volatile仅保证了对变量的读写可见性，却无法确保操作的原子性。所谓原子性，指的是一个操作不可被打断的特性。在多线程环境中，一个非原子操作可能会被其他线程干扰，导致结果不一致。

一个典型的例子是自增操作i++。虽然自增看似是一个简单的操作，但它实际包含三个步骤：

读取变量的当前值；
对变量的值加1；
将新值写回变量。

在并发情况下，这三个步骤可能会被其他线程打断，从而导致读取的值是过期的，最终导致错误的结果。即使将变量声明为volatile，这三个步骤仍然是分开的，依然不能保证其原子性。

示例：多线程下的非原子性问题

考虑以下代码，它创建了5个线程，每个线程对count变量执行10次自增操作：

private static volatile int count = 0;

public static void main(String[] args) {
    
    
    Thread[] threads = new Thread[5];
    for (int i = 0; i < 5; i++) {
    
    
        threads[i] = new Thread(() -> {
    
    
            try {
    
    
                for (int j = 0; j < 10; j++) {
    
    
                    System.out.println(++count);
                    Thread.sleep(500);
                }
            } catch (Exception e) {
    
    
                e.printStackTrace();
            }
        });
        threads[i].start();
    }
}

~忽略中间部分

理论上，count的值应该从1增加到50，但是实际输出的结果可能是错乱的。这是因为自增操作count++在多线程环境中并非原子操作。

字节码分析：揭示非原子性原因

通过查看字节码可以更清晰地理解为什么i++不是一个原子操作。假设有如下代码：

private static volatile int count = 0;

public static void increment() {
    
    
    count++;
}

count++操作的字节码如下：

0: getstatic     #2    // 获取静态变量 count 的值
3: iconst_1            // 将常量 1 压入栈
4: iadd                // 将栈顶的两个值相加
5: putstatic     #2    // 将相加结果写回 count
8: return              // 返回

分解解释如下：

getstatic：从主内存中获取count的值并将其压入栈。
iconst_1：将常量1压入栈，准备进行加法操作。
iadd：将栈顶的两个值（即count和1）相加，并将结果存入栈顶。
putstatic：将栈顶值写回count。

在多线程环境中，如果多个线程同时执行这些指令，count在iadd执行前可能已经被其他线程修改了值。因为整个操作不是原子性，所以即使声明为volatile，count的结果依旧无法保证正确性。

保证原子性的方案：结合CAS机制

为了解决这个问题，Java提供了CAS（Compare-And-Swap）机制。在CAS中，变量更新操作只会在变量的当前值与预期值相等时才会执行，从而保证更新操作的原子性。CAS应用广泛，最常见的场景是AtomicInteger：

private static AtomicInteger count = new AtomicInteger(0);

public static void main(String[] args) {
    
    
    Thread[] threads = new Thread[5];
    for (int i = 0; i < 5; i++) {
    
    
        threads[i] = new Thread(() -> {
    
    
            for (int j = 0; j < 10; j++) {
    
    
                System.out.println(count.incrementAndGet());
            }
        });
        threads[i].start();
    }
}

在这里，我们用AtomicInteger替代了int，并用incrementAndGet()方法替代自增操作。AtomicInteger使用了CAS，确保了操作的原子性。运行后我们可以得到正确的结果，因为CAS保证了并发情况下count变量的正确更新。

总结

volatile关键字在多线程环境中提供了可见性和有序性的保证，但无法确保原子性。它适合用于简单的标记变量，但在涉及复杂操作（如自增）时，依然需要额外的手段来保证原子性，例如CAS或锁机制。通过理解volatile的作用和局限性，可以更好地编写出线程安全的代码。