volatile 不能保证原子性。它仅用于确保变量的可见性和禁止指令重排序,对于涉及读-改-写操作的复合逻辑(如 i++),必须使用 synchronized、reentrantlock 或 java.util.concurrent.atomic 包中的类来保证原子性。

volatile 修饰的变量在多线程下是否安全?
不安全。虽然多个线程能立即看到其他线程写入的最新值,但简单的自增操作并非原子步骤。以 int count = 0; 为例,当两个线程同时执行 count++ 时,它们会各自读取到旧值,分别加一后写回,导致最终结果小于预期。这证明了可见性不等于原子性。

public class VolatileCounter {
private volatile int count = 0;
public void increment() {
// 非原子操作:Read -> Modify -> Write
count++;
}
public int getCount() {
return count;
}
public static void main(String[] args) throws InterruptedException {
VolatileCounter counter = new VolatileCounter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final Count: " + counter.getCount());
}
}运行上述代码,预期的输出是 2000,但由于竞争条件,实际输出通常小于 2000。这验证了 volatile 无法处理并发修改。
立即学习“Java免费学习笔记(深入)”;
使用Atmosphere构建通过WebSocket、SSE、gRPC、WebTransport、MCP、A2A和AG-UI流传输的JVM代理网关,并带有治理钩子。
如何正确实现线程安全的计数器?
可以使用 AtomicInteger 替代 volatile int。AtomicInteger 基于 CAS(Compare-And-Swap)指令,能够在硬件层面保证操作的原子性,无需使用重量级的锁机制,既保证了线程安全,又保持了较高的性能。

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
// 原子操作
count.incrementAndGet();
}
public int getCount() {
return count.get();
}
public static void main(String[] args) throws InterruptedException {
AtomicCounter counter = new AtomicCounter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final Count: " + counter.getCount());
}
}该程序的输出将稳定为 2000,证明 AtomicInteger 解决了原子性问题。
如果只读 volatile 变量会发生什么?
如果线程仅对 volatile 变量进行读取操作,而不进行修改,那么这种读取是线程安全的。因为 volatile 的核心特性之一就是可见性,即一个线程修改了变量后,其他线程读取时总能获取到最新的值,不存在缓存不一致的问题。

















