Java线程安全是多线程编程中必须关注的核心问题，其本质可以拆解为原子性、可见性、有序性三个维度，每个维度对应不同的并发风险，需要针对性的代码手段来保障。
一、原子性维度与代码保障
原子性指的是一个操作或者多个操作要么全部执行并且执行过程不被打断，要么就都不执行。如果操作不具备原子性，多线程并发执行时就可能出现数据不一致的问题。
比如下面的非原子性计数代码，两个线程同时执行自增操作，最终结果可能小于预期：
public class AtomicDemo {
private int count = 0;
public void increment() {
// 自增操作不是原子操作，包含读取、加1、写入三步
count++;
}
public static void main(String[] args) throws InterruptedException {
AtomicDemo demo = new AtomicDemo();
// 创建两个线程同时执行自增操作
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
demo.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
demo.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
// 预期结果是20000，实际可能小于这个值
System.out.println(demo.count);
}
}
保障原子性的常用方案有两种，一种是使用synchronized关键字加锁，另一种是使用原子类：
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicFixDemo {
// 方案1：使用synchronized修饰方法保证原子性
private int count1 = 0;
public synchronized void increment1() {
count1++;
}
// 方案2：使用AtomicInteger原子类
private AtomicInteger count2 = new AtomicInteger(0);
public void increment2() {
count2.incrementAndGet();
}
}
二、可见性维度与代码保障
可见性指的是当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。如果缺乏可见性保障，线程可能读取到过期的变量值，导致逻辑错误。
下面是没有可见性保障的代码示例，一个线程修改标记变量，另一个线程可能无法及时感知到修改：
public class VisibilityDemo {
// 没有可见性保障的标记变量
private boolean flag = false;
public void changeFlag() {
// 修改标记变量
flag = true;
System.out.println("标记已修改为true");
}
public void readFlag() {
// 循环读取标记变量，可能一直读取到false
while (!flag) {
}
System.out.println("读取到标记为true，退出循环");
}
public static void main(String[] args) throws InterruptedException {
VisibilityDemo demo = new VisibilityDemo();
new Thread(demo::readFlag).start();
Thread.sleep(1000);
new Thread(demo::changeFlag).start();
}
}
保障可见性的常用方案是使用volatile关键字修饰共享变量，或者利用锁的可见性特性：
public class VisibilityFixDemo {
// 使用volatile修饰，保证可见性
private volatile boolean flag = false;
public void changeFlag() {
flag = true;
System.out.println("标记已修改为true");
}
public void readFlag() {
while (!flag) {
}
System.out.println("读取到标记为true，退出循环");
}
}
三、有序性维度与代码保障
有序性指的是程序执行的顺序按照代码的先后顺序执行。由于指令重排序的存在，实际执行顺序可能和代码顺序不一致，在多线程场景下可能导致逻辑错误。
典型的双重检查锁单例模式中，如果没有有序性保障，可能出现对象半初始化的问题：
public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo() {}
public static SingletonDemo getInstance() {
if (instance == null) {
synchronized (SingletonDemo.class) {
if (instance == null) {
// 这里可能发生指令重排序，先赋值再初始化对象
instance = new SingletonDemo();
}
}
}
return instance;
}
}
保障有序性的方案同样是使用volatile关键字修饰相关变量，禁止指令重排序：
public class SingletonFixDemo {
// 使用volatile修饰，禁止指令重排序
private static volatile SingletonFixDemo instance;
private SingletonFixDemo() {}
public static SingletonFixDemo getInstance() {
if (instance == null) {
synchronized (SingletonFixDemo.class) {
if (instance == null) {
instance = new SingletonFixDemo();
}
}
}
return instance;
}
}
三个维度的关联与总结
原子性、可见性、有序性三者共同构成了Java线程安全的完整保障体系，很多时候一个并发问题可能涉及多个维度。比如synchronized关键字同时可以保障原子性、可见性和有序性，而volatile关键字主要保障可见性和有序性，不保障原子性。开发者需要根据实际场景选择合适的保障手段，才能写出可靠的并发代码。