JAVA并发编程中的不可见性问题、JMM与volatile优化策略
大家好，今天我们来深入探讨Java并发编程中一个非常重要的概念：不可见性（Visibility）。不可见性问题常常是导致并发错误的重要原因，理解它的本质以及Java内存模型（JMM）如何解决这个问题，对于编写正确、高效的并发程序至关重要。我们将深入分析不可见性产生的原因，JMM的工作原理，以及如何使用volatile关键字来优化并发代码。
一、不可见性：并发错误的隐形杀手
在单线程环境下，变量的读取和写入操作很简单，可以直接从内存中进行。但在多线程环境下，每个线程都有自己的工作内存（Working Memory），它是主内存（Main Memory）的副本。线程的操作都在自己的工作内存中进行，而不是直接操作主内存。这会导致一个线程对变量的修改，对其他线程来说可能不可见，从而引发各种并发问题。
考虑以下代码：
public class VisibilityExample {
private static boolean running = true;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while (running) {
// do something
}
System.out.println("Thread 1 finished");
});
t1.start();
Thread.sleep(1000);
running = false;
System.out.println("Main thread set running to false");
}
}这段代码的逻辑很简单：线程 t1 不断循环，直到 running 变量变为 false。主线程在睡眠 1 秒后将 running 设置为 false，希望 t1 线程能结束循环。
然而，在实际运行中，你可能会发现 t1 线程并没有如预期那样结束，而是陷入了无限循环。这就是典型的不可见性问题。
原因分析：
- 线程工作内存：
t1线程启动后，会将running变量的值从主内存拷贝到自己的工作内存中。 - 修改未同步： 主线程将
running设置为false后，这个修改只会发生在主线程的工作内存中，并不会立即同步到主内存。 - 过时数据：
t1线程仍然在自己的工作内存中使用过时的running值（true），因此会一直循环下去。
如何证明不可见性？
我们可以通过添加一些输出语句或者进行一些看似无意义的操作来“修复”这个问题，例如：
public class VisibilityExample {
private static boolean running = true;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while (running) {
// do something
System.out.println("Thread 1 is running"); // 添加输出语句
}
System.out.println("Thread 1 finished");
});
t1.start();
Thread.sleep(1000);
running = false;
System.out.println("Main thread set running to false");
}
}或者：
public class VisibilityExample {
private static boolean running = true;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while (running) {
// do something
try {
Thread.sleep(1); // 添加休眠
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Thread 1 finished");
});
t1.start();
Thread.sleep(1000);
running = false;
System.out.println("Main thread set running to false");
}
}你会发现，添加这些看似无关紧要的代码后，t1 线程很有可能能够正确结束。这是因为 System.out.println 和 Thread.sleep 方法内部可能会涉及到一些同步操作，例如刷新缓存，从而间接导致 running 变量的值被同步到主内存，进而被 t1 线程读取到。
不可见性问题的危害：
不可见性不仅仅会导致简单的死循环，更可能导致程序逻辑错误，数据不一致，甚至崩溃。在复杂的并发系统中，这种隐藏的bug往往难以追踪和调试。
二、Java内存模型（JMM）：解决并发问题的基石
Java内存模型 (JMM) 定义了Java程序中各个变量（包括实例字段、静态字段和构成数组对象的元素，但不包括局部变量和方法参数，因为它们是线程私有的）的访问方式。JMM围绕着在并发过程中如何处理原子性、可见性和有序性这三个特征来建立的，其中可见性就是我们今天要重点关注的。
JMM的主要目标：
- 保证可见性： 确保一个线程对共享变量的修改能够及时被其他线程看到。
- 保证原子性： 确保一个操作不会被线程调度器中断，要么全部执行完毕，要么完全不执行。
- 保证有序性： 确保程序的执行顺序按照代码的先后顺序执行（在不影响单线程执行结果的前提下，允许进行指令重排序）。
JMM抽象结构：
JMM可以抽象地描述为：所有变量都存储在主内存中，每个线程都有自己的工作内存。工作内存中保存了该线程使用到的变量的主内存副本拷贝。线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递需要通过主内存来完成。
可以用下面的表格来总结：
| 概念 | 描述 |
|---|---|
| 主内存 (Main Memory) | 所有线程共享的内存区域，存储着共享变量。 |
| 工作内存 (Working Memory) | 每个线程私有的内存区域，存储着线程使用到的变量的主内存副本。线程对变量的操作都在工作内存中进行。 |
| 变量 | 实例字段、静态字段、数组元素，但不包括局部变量和方法参数。 |
| 操作 | 读取 (read)、加载 (load)、使用 (use)、赋值 (assign)、存储 (store)、写入 (write)、锁定 (lock)、解锁 (unlock)。这些操作定义了线程和主内存之间的数据交互。 |
JMM如何保证可见性？
JMM定义了一系列规则来保证可见性，这些规则可以概括为：
- 线程在修改共享变量后，必须立即将修改后的值写回主内存。
- 线程在读取共享变量时，必须从主内存中重新加载最新的值。
这些规则看似简单，但实际实现却比较复杂，需要通过底层的硬件和操作系统的支持。Java提供了多种机制来保证可见性，其中最常用的就是 volatile 关键字。
三、volatile关键字：轻量级的同步机制
volatile 关键字是Java提供的一种轻量级的同步机制，它可以保证变量的可见性，并禁止指令重排序。
volatile 的作用：
- 可见性保证： 当一个变量被声明为
volatile时，任何线程对该变量的修改都会立即刷新到主内存，并且其他线程在读取该变量时，会强制从主内存中重新加载最新的值。 - 禁止指令重排序：
volatile关键字可以防止编译器和处理器对指令进行重排序，从而保证程序的执行顺序按照代码的先后顺序执行。
如何使用 volatile？
只需要在变量声明前加上 volatile 关键字即可：
private volatile static boolean running = true;修改之前的 VisibilityExample 代码，将 running 变量声明为 volatile：
public class VisibilityExample {
private volatile static boolean running = true;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while (running) {
// do something
}
System.out.println("Thread 1 finished");
});
t1.start();
Thread.sleep(1000);
running = false;
System.out.println("Main thread set running to false");
}
}现在，t1 线程就能正确结束循环了。因为主线程对 running 变量的修改能够立即被 t1 线程看到。
volatile 的实现原理：
volatile 关键字的实现原理涉及到硬件层面的内存屏障（Memory Barrier）。内存屏障是一种CPU指令，它可以强制将缓存中的数据写回主内存，并使缓存失效，从而保证可见性。
简单来说，当一个线程写入一个 volatile 变量时，会在该变量的写入操作前后插入写屏障（Store Barrier）。写屏障会强制将工作内存中修改后的值立即刷新到主内存。
当一个线程读取一个 volatile 变量时，会在该变量的读取操作前后插入读屏障（Load Barrier）。读屏障会强制从主内存中重新加载最新的值到工作内存。
volatile 的适用场景：
volatile 关键字适用于以下场景：
- 一个线程写入，多个线程读取：
volatile只能保证单个变量的可见性，如果多个线程同时修改同一个volatile变量，仍然可能出现并发问题。 - 变量的写入不依赖于当前值：
volatile无法保证原子性，如果变量的写入操作依赖于当前值（例如count++），仍然需要使用锁或其他同步机制。
volatile 不能保证原子性：
volatile 只能保证变量的可见性，但不能保证原子性。例如，count++ 操作实际上包含了三个步骤：
- 读取
count的值。 - 将
count的值加 1。 - 将加 1 后的值写回
count。
即使 count 变量被声明为 volatile，这三个步骤仍然可能被中断，导致多个线程同时修改 count 变量时出现错误。
考虑以下代码：
public class VolatileAtomicityExample {
private volatile static int count = 0;
public static void main(String[] args) throws InterruptedException {
Thread[] threads = new Thread[10];
for (int i = 0; i < 10; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 1000; j++) {
count++;
}
});
threads[i].start();
}
for (int i = 0; i < 10; i++) {
threads[i].join();
}
System.out.println("Count = " + count);
}
}这段代码创建了 10 个线程，每个线程将 count 变量递增 1000 次。理论上，最终 count 的值应该是 10000。但实际运行结果往往小于 10000。这就是因为 volatile 无法保证 count++ 操作的原子性。
如何保证原子性？
可以使用 synchronized 关键字或者 java.util.concurrent.atomic 包下的原子类来保证原子性。例如，可以使用 AtomicInteger 类来替代 int 类型的 count 变量：
import java.util.concurrent.atomic.AtomicInteger;
public class VolatileAtomicityExample {
private static AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
Thread[] threads = new Thread[10];
for (int i = 0; i < 10; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 1000; j++) {
count.incrementAndGet();
}
});
threads[i].start();
}
for (int i = 0; i < 10; i++) {
threads[i].join();
}
System.out.println("Count = " + count.get());
}
}AtomicInteger 类的 incrementAndGet() 方法是一个原子操作，可以保证 count 变量的递增操作是原子性的。
四、Happen-Before原则：JMM的有序性保证
除了可见性之外，JMM还定义了一系列的Happen-Before原则，来保证程序的有序性。Happen-Before原则描述了两个操作之间的happens-before关系。如果一个操作happens-before另一个操作，那么就意味着第一个操作的结果对第二个操作是可见的，并且第一个操作的执行顺序排在第二个操作之前。
常见的Happen-Before原则：
- 程序顺序规则： 在一个线程内，按照代码的先后顺序，前面的操作 happens-before 后面的操作。
- 管程锁定规则： 一个 unlock 操作 happens-before 后面对同一个锁的 lock 操作。
- volatile变量规则： 对一个 volatile 变量的写操作 happens-before 后面对这个变量的读操作。
- 线程启动规则： Thread 对象的 start() 方法 happens-before 此线程的每一个动作。
- 线程终止规则： 线程的所有操作 happens-before 此线程的终止检测，可以通过 Thread.join() 方法结束、Thread.isAlive() 的返回值等手段检测到线程已经终止执行。
- 线程中断规则： 对线程 interrupt() 方法的调用 happens-before 被中断线程的代码检测到中断事件的发生，可以通过 Thread.isInterrupted() 方法检测是否有中断发生。
- 对象终结规则： 一个对象的初始化完成 happens-before 它的 finalize() 方法的开始。
- 传递性： 如果操作 A happens-before 操作 B，操作 B happens-before 操作 C，那么操作 A happens-before 操作 C。
Happen-Before原则是判断数据是否存在竞争，线程是否安全的主要依据。依赖这些原则，可以分析并发代码的正确性。
五、总结：理解并发编程的关键概念
本文深入探讨了Java并发编程中不可见性问题，分析了JMM的工作原理，以及如何使用volatile关键字来解决不可见性问题。希望通过本文的学习，你能够更好地理解Java并发编程的关键概念，编写出更加安全、高效的并发程序。volatile 是轻量级的同步工具，但要谨慎使用，并且要结合具体场景选择合适的同步机制。理解JMM和Happen-Before原则是构建可靠并发程序的基石。