在 Java 编程的世界里，多线程就像是一群忙碌的工人同时在一个大工厂里工作。每个工人都有自己的小空间来放工具和材料（局部变量），他们也会共享一些大仓库里的资源（全局变量）。但是，有时候这些工人在拿取或者存放共享资源时会出现一些问题，这就是我们要聊的多线程内存可见性问题。而 JVM 内存屏障就是解决这个问题的关键工具。
一、多线程内存可见性问题初体验
咱们先来看个小例子，就拿 Java 代码来说：
// Java 技术栈示例
class VisibilityExample {
// 共享变量
static boolean flag = false;
public static void main(String[] args) {
// 创建一个新线程
Thread t1 = new Thread(() -> {
while (!flag) {
// 线程1在这里不断循环，直到 flag 变为 true
}
System.out.println("Thread 1: flag is now true");
});
t1.start();
try {
// 主线程休眠一小段时间，确保线程1先开始执行
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 主线程修改共享变量
flag = true;
System.out.println("Main thread: flag is set to true");
}
}
在这个例子里，有两个线程，一个主线程，一个 t1 线程。t1 线程在一个 while 循环里不停地检查 flag 这个共享变量。主线程休眠 1 秒后把 flag 改成 true 。按照我们正常的想法，t1 线程应该能马上看到 flag 变成了 true ，然后跳出循环，输出 "Thread 1: flag is now true" 。可实际上呢，可能 t1 线程根本就看不到 flag 的变化，一直卡在循环里出不来。这就是多线程内存可见性问题。
二、内存的结构和工作原理
要想弄明白为啥会出现上面的问题，就得先了解一下 Java 内存的结构。在 Java 里，内存主要分成两部分：主内存和工作内存。主内存就像是那个大仓库，存放着所有的共享变量。每个线程都有自己的工作内存，就像工人的小空间，线程会把主内存里的共享变量拷贝一份到自己的工作内存里，然后就在自己的工作内存里对这个变量进行操作。操作完了，再把结果写回主内存。
还是拿上面的例子来说，t1 线程把 flag 变量从主内存拷贝到自己的工作内存里，然后就在自己的工作内存里一直检查 flag 的值。主线程把主内存里的 flag 改成 true 后，t1 线程的工作内存里的 flag 可能还是 false ，它根本不知道主内存里的值已经变了，所以就一直卡在循环里。
三、JVM 内存屏障闪亮登场
JVM 内存屏障就是用来解决这个问题的。简单来说，内存屏障就像是一个关卡，它会确保在它之前的所有操作都已经完成，并且对其他线程可见，然后才允许后面的操作执行。Java 里有几种不同类型的内存屏障，不过咱们主要聊两种：写屏障和读屏障。
写屏障
写屏障会确保在写屏障之前的所有写操作都已经完成，并且把这些写操作的结果刷新到主内存里，让其他线程能看到。咱们把上面的例子改一下，加个写屏障试试：
// Java 技术栈示例
import java.util.concurrent.atomic.AtomicBoolean;
class WriteBarrierExample {
// 使用 AtomicBoolean 内部会利用内存屏障
static AtomicBoolean flag = new AtomicBoolean(false);
public static void main(String[] args) {
// 创建一个新线程
Thread t1 = new Thread(() -> {
while (!flag.get()) {
// 线程1在这里不断循环，直到 flag 变为 true
}
System.out.println("Thread 1: flag is now true");
});
t1.start();
try {
// 主线程休眠一小段时间，确保线程1先开始执行
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 使用 AtomicBoolean 的 set 方法，内部会有写屏障
flag.set(true);
System.out.println("Main thread: flag is set to true");
}
}
在这个例子里，我们用了 AtomicBoolean 来替代普通的 boolean 变量。AtomicBoolean 的 set 方法在内部会使用写屏障，这样主线程把 flag 改成 true 后，会确保这个修改马上刷新到主内存里，t1 线程就能看到最新的值，然后跳出循环。
读屏障
读屏障会确保在它之后的所有读操作都能读到最新的值。也就是说，在读屏障之后的读操作，会先把主内存里的最新值加载到自己的工作内存里，再进行读取。
// Java 技术栈示例
import java.util.concurrent.atomic.AtomicBoolean;
class ReadBarrierExample {
// 使用 AtomicBoolean 内部会利用内存屏障
static AtomicBoolean flag = new AtomicBoolean(false);
public static void main(String[] args) {
// 创建一个新线程
Thread t1 = new Thread(() -> {
while (true) {
// 使用 AtomicBoolean 的 get 方法，内部会有读屏障
if (flag.get()) {
System.out.println("Thread 1: flag is now true");
break;
}
}
});
t1.start();
try {
// 主线程休眠一小段时间，确保线程1先开始执行
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 使用 AtomicBoolean 的 set 方法，内部会有写屏障
flag.set(true);
System.out.println("Main thread: flag is set to true");
}
}
在这个例子里，AtomicBoolean 的 get 方法在内部会使用读屏障，t1 线程在读取 flag 的值时，会先把主内存里的最新值加载到自己的工作内存里，这样就能读到主线程修改后的最新值。
四、应用场景大揭秘
多线程计数器
在多线程环境下，我们经常会用到计数器。比如，统计网站的访问量，每个线程在用户访问时都会对计数器加 1。如果不使用内存屏障，就可能会出现数据不一致的问题。
// Java 技术栈示例
import java.util.concurrent.atomic.AtomicInteger;
class CounterExample {
// 使用 AtomicInteger 作为计数器，内部利用内存屏障保证可见性
static AtomicInteger counter = 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++) {
// 使用 AtomicInteger 的 incrementAndGet 方法，内部有写屏障
counter.incrementAndGet();
}
});
threads[i].start();
}
for (Thread thread : threads) {
thread.join();
}
System.out.println("Final counter value: " + counter.get());
}
}
在这个例子里，我们用 AtomicInteger 作为计数器。AtomicInteger 的 incrementAndGet 方法在内部会使用写屏障，确保每个线程对计数器的修改都能马上刷新到主内存里，其他线程能看到最新的值，这样就能保证计数器的准确性。
线程间的同步
在一些场景下，我们需要一个线程等待另一个线程完成某个操作后再继续执行。比如，一个线程负责初始化资源，另一个线程需要等资源初始化完成后才能使用。
// Java 技术栈示例
import java.util.concurrent.atomic.AtomicBoolean;
class ThreadSyncExample {
// 使用 AtomicBoolean 来标记资源是否初始化完成
static AtomicBoolean initialized = new AtomicBoolean(false);
public static void main(String[] args) {
// 初始化线程
Thread initThread = new Thread(() -> {
// 模拟资源初始化操作
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 初始化完成，设置标记
initialized.set(true);
System.out.println("Resource initialized");
});
// 使用资源的线程
Thread useThread = new Thread(() -> {
while (!initialized.get()) {
// 等待资源初始化完成
}
System.out.println("Using the resource");
});
initThread.start();
useThread.start();
}
}
在这个例子里，initialized 是一个 AtomicBoolean 变量。初始化线程在完成资源初始化后，会使用写屏障把 initialized 的值改成 true ，并刷新到主内存里。使用资源的线程在读取 initialized 的值时，会使用读屏障，确保能读到最新的值，这样就能在资源初始化完成后再使用资源。
五、技术优缺点分析
优点
- 保证内存可见性：这是最主要的优点，通过使用内存屏障，能确保线程之间对共享变量的修改能及时被其他线程看到，避免了数据不一致的问题。
- 简单易用：在 Java 里，很多类（比如
Atomic系列的类）都已经帮我们封装好了内存屏障的操作，我们只需要使用这些类，就能很方便地解决多线程内存可见性问题。 - 性能相对较好：虽然内存屏障会有一定的性能开销，但是相比于使用锁来保证线程安全，内存屏障的性能要好很多。因为锁会导致线程的阻塞和唤醒，而内存屏障只是在必要的时候确保数据的可见性，不会阻塞线程。
缺点
- 增加代码复杂度：如果我们要手动使用内存屏障，就需要对 Java 的内存模型有深入的了解，这会增加代码的复杂度。而且，不同类型的内存屏障使用起来也比较复杂，容易出错。
- 性能开销：虽然内存屏障的性能相对较好，但是它还是会有一定的性能开销。尤其是在高并发的场景下，频繁使用内存屏障会影响程序的性能。
六、注意事项要牢记
不要滥用内存屏障
内存屏障虽然能解决多线程内存可见性问题，但是也不能滥用。如果在不需要保证内存可见性的地方使用了内存屏障，会增加程序的性能开销。比如，在单线程环境下，就不需要使用内存屏障。
了解不同类型的内存屏障
Java 里有几种不同类型的内存屏障，每种内存屏障的作用都不一样。我们要了解这些内存屏障的特点，根据具体的需求选择合适的内存屏障。比如，在写操作后需要确保其他线程能看到最新值时，就使用写屏障；在读操作前需要确保读到最新值时，就使用读屏障。
结合其他同步机制
内存屏障只是解决多线程内存可见性问题的一种手段，在实际开发中，我们还需要结合其他的同步机制（比如锁）来保证线程安全。比如，在对共享资源进行读写操作时，除了使用内存屏障保证可见性，还需要使用锁来保证操作的原子性。
七、文章总结
多线程内存可见性问题是 Java 多线程编程中一个很重要的问题，如果处理不好，会导致程序出现各种奇怪的 bug。JVM 内存屏障是解决这个问题的关键工具，它能确保线程之间对共享变量的修改能及时被其他线程看到。我们介绍了 Java 内存的结构和工作原理，以及写屏障和读屏障的作用。还通过几个具体的例子，展示了内存屏障在多线程计数器和线程间同步等场景下的应用。同时，我们也分析了内存屏障的优缺点，以及使用时需要注意的事项。在实际开发中，我们要合理使用内存屏障，结合其他同步机制，确保程序的正确性和性能。
评论