java 中利用 volatile 和 countdownlatch 协调线程,核心在于用 countdownlatch 确保工作线程在启动时能观察到主线程对共享变量的初始化或状态设置。具体做法是:主线程先创建 countdownlatch(1),然后修改需要被观察的 volatile 变量,最后调用 countdown();工作线程启动后调用 await() 阻塞等待,直到主线程释放锁存器,此时工作线程读取 volatile 变量即可看到最新值。

为什么 CountDownLatch 能保证 volatile 可见性?
CountDownLatch 的 countDown() 操作与后续 await() 的返回之间存在 happens-before 关系。根据 Java 内存模型(JMM),如果线程 A 在释放锁存器之前写入了一个 volatile 变量,那么在线程 B 成功从 await() 返回后,它一定能读到该 volatile 变量的最新值。这相当于用 CountDownLatch 建立了一个临时的“屏障”,确保了跨线程的状态同步。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class VolatileLatchDemo {
// 定义 volatile 变量,用于存储工作配置
private static volatile String config = "DEFAULT";
public static void main(String[] args) throws InterruptedException {
// 1. 创建锁存器,计数为 1
CountDownLatch latch = new CountDownLatch(1);
// 2. 提交任务到线程池
ExecutorService executor = Executors.newFixedThreadPool(2);
for (int i = 0; i {
try {
// 3. 工作线程等待主线程的信号
latch.await();
// 4. 等待结束后,读取 volatile 变量
System.out.println("Task " + taskId + " sees config: " + config);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
// 5. 主线程更新 volatile 变量
config = "PRODUCER_CONFIG";
System.out.println("Main thread updated config to: " + config);
// 6. 主线程释放锁存器
latch.countDown();
executor.shutdown();
}
}
运行上述代码,控制台输出将显示两个任务都打印出 PRODUCER_CONFIG。这是因为主线程在调用 latch.countDown() 之前已经完成了对 config 的赋值。由于 config 是 volatile 的,且 countDown() 与 await() 存在 happens-before 关系,工作线程在 await() 返回后,必然能看到 config 的最新值。
如果去掉 volatile 会发生什么?
如果将 config 声明为非 volatile 普通变量,即使使用了 CountDownLatch,工作线程也可能读到旧值 DEFAULT。这是因为 CountDownLatch 本身并不保证对其外部变量的可见性,它只保证自身的内部状态同步。只有当被共享的变量也是 volatile 的,或者通过其他同步机制(如 synchronized)保护时,CountDownLatch 建立的 happens-before 关系才能传递到该变量上。
FilePond 是一个 JavaScript 文件上传库,支持通过拖拽、粘贴和 API 方式处理文件、目录、URL 和 Data URI。它包含内置的图像优化功能、异步分块上传功能,并提供了适用于 React、Vue、Angular 和 Svelte 的适配器。

import java.util.concurrent.CountDownLatch;
public class NonVolatileFailDemo {
// 注意:这里去掉了 volatile 关键字
private static String config = "DEFAULT";
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(1);
// 模拟多个工作线程
Thread t1 = new Thread(() -> {
try {
latch.await();
System.out.println("Thread-1 sees config: " + config);
} catch (InterruptedException e) {}
});
Thread t2 = new Thread(() -> {
try {
latch.await();
System.out.println("Thread-2 sees config: " + config);
} catch (InterruptedException e) {}
});
t1.start();
t2.start();
// 主线程更新非 volatile 变量
config = "PRODUCER_CONFIG";
latch.countDown();
t1.join();
t2.join();
}
}
在这个修改后的示例中,虽然逻辑结构相同,但 config 不再是 volatile。JMM 规定,如果没有同步措施,一个线程对非 volatile 变量的写入对其他线程是不可见的。尽管 latch.countDown() 和 latch.await() 之间有同步点,但这个同步点仅作用于 CountDownLatch 的内部状态,不能自动扩展到外部的 config 变量。因此,工作线程可能因为缓存一致性协议未刷新而读到旧值。要修复此问题,必须重新添加 volatile 关键字或使用 AtomicReference 等原子类。
CountDownLatch 的 countDown() 必须在 volatile 写入之后吗?
是的,countDown() 必须在对 volatile 变量的写入操作之后执行,否则无法保证可见性。如果主线程先调用 countDown(),再更新 volatile 变量,那么工作线程可能在 await() 返回后立即读取变量,此时主线程的写入尚未完成或未被其他线程感知。正确的顺序是:先写 volatile 变量,再调用 countDown()。这样,volatile 写入的 happens-before 关系会传递给 countDown(),进而传递给所有 await() 的线程,确保它们看到的是最新的 volatile 值。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南










