深入浅出：线程安全问题的原因与解决方案

原创已于 2025-05-21 15:59:25 修改 · 1.1k 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#安全 #笔记 #java #jvm #操作系统 #多线程

于 2025-05-21 15:52:11 首次发布

操作系统专栏收录该内容

11 篇文章

订阅专栏

一、什么是线程安全问题？
二、线程不安全的五大原因
三、线程安全问题的解决方案
四、总结
结语

一、什么是线程安全问题？

当多个线程同时执行某段代码时，由于操作系统的抢占式调度和线程对共享资源的无序访问，可能导致数据错乱或程序异常。理解线程安全是编写可靠并发程序的关键。

二、线程不安全的五大原因

1. 抢占式执行（根本原因）

操作系统对线程的调度是“抢占式”的，线程可能在任何时刻被中断，导致代码执行顺序不可预测。

2. 多线程修改同一共享变量

多个线程同时操作同一个变量时，若未同步控制，结果可能因指令交错而错误。

3. 非原子操作

（1）原子性定义

原子性：不可分割的最小操作单位。
非原子操作示例：count++ 在 CPU 层面分解为三步：

// Java代码：
count++;  

// CPU视角：  
1. load：将内存中的 count 值读取到寄存器（假设读取到 0）  
2. add：将寄存器的值加 1（寄存器值变为 1）  
3. save：将寄存器的值写回内存（count 变为 1）

（2）指令交错：抢占式调度的“恶作剧”

假设线程 A 和线程 B 同时执行 count++，由于操作系统的抢占式调度，它们的指令可能以任意顺序交替执行。以下是两种典型的错误场景：
场景一：线程 A 的 save 被线程 B 覆盖

线程A	线程B	内存中的 count
load → 读取 0		0
add → 寄存器变为 1		0
	load → 读取 0	0
	add → 寄存器变为 1	0
save → 写回 1		1
	save → 写回 1	1

结果：两个线程执行后，count 的值是 1（预期是 2）。
场景二：线程 B 的 load 发生在线程 A 的 save 之前

线程A	线程B	内存中的 count
load → 读取 0		0
add → 寄存器变为 1		0
	load → 读取 0	0
save → 写回 1		1
	add → 寄存器变为 1	1
	save → 写回 1	1

结果：同样是 1，而非预期的 2。

（3）为什么会发生指令交错？

抢占式调度：操作系统随时可能中断当前线程，让其他线程执行。
非原子操作：count++ 包含三个指令，线程可能在任意一步被切换。
不可预测性：你无法控制线程何时被中断，也无法预知指令执行顺序。

4. 内存可见性问题

问题本质：
当多个线程访问同一变量时，由于 JVM的内存模型优化 和 CPU缓存机制，一个线程对变量的修改可能不会立即被其他线程看到，导致数据不一致。

详细解释

（1）JVM的优化行为
观察以下代码：

// 共享变量
private static int n = 0;

Thread A = new Thread(() -> {
	while (n == 0) { // 读取共享变量
		/* 空循环 */
	}
	/* n被线程B修改后，线程A依然没有退出循环 */
	System.out.println("线程A退出");
});

Thread B = new Thread(() -> {
	/* 让线程A执行一段时间后修改共享变量 */
	n = 1; // 修改共享变量，尝试终止线程A
});

预期行为：线程B修改 n = 1 后，线程A应退出循环。
实际可能行为：线程A永远无法退出。

（2）原因分析

JVM的“提升”优化：
- JVM发现 while(n == 0) 循环中 n 未被修改，会将 n 的值从内存缓存到寄存器，后续直接读取寄存器值（不在访问内存）。
- 即使线程B修改了内存中的 n，线程A仍读取旧的寄存器值。
CPU缓存一致性协议：
- 现代CPU有多级缓存（L1/L2/L3），线程可能读取到其他CPU核心的过期缓存。
- 若变量未标记为 volatile，JVM不强制刷新缓存。

5. 指令重排序

问题本质：
JVM 或编译器为了提高性能，可能会在不改变单线程执行结果的前提下，重新排列指令的执行顺序。但在多线程环境下，这种优化可能导致其他线程观察不到不符合逻辑的中间状态，引发安全问题。
一个简单示例：标志位与数据初始化

// 共享变量  
boolean flag = false;  
String data = null;  

// 线程1：初始化数据后设置标志位  
Thread t1 = new Thread(() -> {  
    data = "初始化完成";  // 步骤1：初始化数据  
    flag = true;         // 步骤2：设置标志位  
});  

// 线程2：等待标志位为 true 后使用数据  
Thread t2 = new Thread(() -> {  
    while (!flag) {  
        // 空循环等待  
    }  
    System.out.println(data.length());  // 预期 data 已初始化  
});

预期行为：

线程1先执行 date = "初始化完成"，再执行 flag = true。
线程2检测到 flag 为 true 后，打印 data 的长度（应为 5）。

实际可能行为：
由于指令重排序，线程1的执行顺序可能被优化为：

先执行 flag = true（步骤2）。
再执行 data = "初始化完成"（步骤1）。

此时，线程2可能在 data 未初始化时读取到 flag = true，导致 NullPointException。

为什么发生指令重排序？

编译器优化：编译器可能认为调整指令顺序能提升执行效率。
CPU 乱序执行：现代 CPU 为提高流水线效率，可能并行执行无依赖的指令。

三、线程安全问题的解决方案

1. 避免共享变量（线程隔离）

通过任务划分，让每个线程操作独立变量，消除竞争状态。
示例：多线程分别计算数组的奇偶下标和。

public class Sum {  
    private static int evenSum = 0;  
    private static int oddSum = 0;  

    public static void main(String[] args) throws InterruptedException {  
        int[] arr = new int[10000000];  
        // 线程1计算偶数下标和  
        Thread t1 = new Thread(() -> {  
            int sum = 0;  
            for (int i = 0; i < arr.length; i += 2) {  
                sum += arr[i];  
            }  
            evenSum = sum;  // 原子赋值  
        });  
        // 线程2计算奇数下标和  
        Thread t2 = new Thread(() -> {  
            int sum = 0;  
            for (int i = 1; i < arr.length; i += 2) {  
                sum += arr[i];  
            }  
            oddSum = sum;  // 原子赋值  
        });  
        t1.start();  
        t2.start();  
        t1.join();  
        t2.join();  
        System.out.println("总和：" + (evenSum + oddSum));  
    }  
}

2. 加锁（`synchronized`）

加锁是解决线程安全问题最核心的手段，其核心思想是通过互斥访问共享资源，避免指令交错。以下是加锁机制的详细解析：

（1）加锁的核心作用

互斥访问：同一时刻，只允许一个线程执行加锁代码块内的操作。
逻辑原子化：将多步操作（如 count++）在逻辑上视为一个不可分割的整体。
示例：

private int count = 0;  
private static Object lock = new Object();  // 锁对象  

Thread A = new Thread(() -> {
	synchronized (lock) {  // 加锁
		count++;
	}
});

Thread B = new Thread(() -> {
	// 线程B内部逻辑
});

效果：线程A执行 count++ 的 load → add → save 时，线程B必须等待，无法插队执行。

（2）`synchronized` 的三种用法

a. 同步代码块

锁对象：必须为对象实例（如 Object、String、自定义类实例）。
代码示例：

private static Object lockObject = new Object();
synchronized (lockObject) {  
    // 需要同步的代码  
}

b. 修饰实例方法

锁对象：当前实例（this），适用于对象级别的同步。
代码示例：

class CounterWithMethod {  
    public int count = 0;  

    public synchronized void add() {  // 锁对象为当前实例（this）  
        count++;  
    }  
}  

public class DemoMethod {  
    public static void main(String[] args) throws InterruptedException {  
        CounterWithMethod counter = new CounterWithMethod();  

        Thread t1 = new Thread(() -> {  
            for (int i = 0; i < 50000; i++) {  
                counter.add();  
            }  
        });  

        Thread t2 = new Thread(() -> {  
            for (int i = 0; i < 50000; i++) {  
                counter.add();  
            }  
        });  

        t1.start();  
        t2.start();  
        t1.join();  
        t2.join();  

        System.out.println("结果：" + counter.count);  // 预期 100000  
    }  
}

典型应用：StringBuffer 的所有方法均为 synchronized，用来保证线程安全。

c. 修饰静态方法

锁对象：类的 Class 对象（如 MyClass.class），适用于全局静态资源的同步。
代码示例：

class StaticCounter {  
    public static int count = 0;  

    public static synchronized void add() {  // 锁对象为 StaticCounter.class  
        count++;  
    }  
}  

public class DemoStaticMethod {  
    public static void main(String[] args) throws InterruptedException {  
        Thread t1 = new Thread(() -> {  
            for (int i = 0; i < 50000; i++) {  
                StaticCounter.add();  
            }  
        });  

        Thread t2 = new Thread(() -> {  
            for (int i = 0; i < 50000; i++) {  
                StaticCounter.add();  
            }  
        });  

        t1.start();  
        t2.start();  
        t1.join();  
        t2.join();  

        System.out.println("结果：" + StaticCounter.count);  // 预期 100000  
    }  
}

典型应用：单例模式的双重校验锁。

（3）锁的关键注意事项

a. 锁对象的选择

必须为对象实例：不能使用基本类型（如 int、double）。
推荐专用锁对象：避免使用业务相关的对象（如 this），防止意外冲突。

b. 可重入性

Java 的 synchronized 是可重入锁：同一线程可重复获取已持有的锁，避免自锁。
示例：

public class ReentrantDemo {  
    private final Object lock = new Object();  // 锁对象  

    public void methodA() {  
        synchronized (lock) {  
            methodB();  // 同一线程再次获取 lock 锁  
        }  
    }  

    public void methodB() {  
        synchronized (lock) {  
            // 可重入：不会阻塞  
        }  
    }  
}

c. 锁粒度优化

尽量缩小缩范围：仅包裹必须同步的代码，减少性能损耗。
错误示例：

synchronized (lock) {  
    // 无关代码（如日志打印、I/O操作）  
    count++;  
}

（4）原生加锁 API 的问题

Java 的 synchronized 是语法糖，底层对应 monitorenter 和 monitorexit 指令。相较显式锁（如 Lock），其优势在于：

自动释放锁：无论代码正常结束或异常退出，synchronized 都能释放锁。
避免忘记 unlock：显式锁需手动调用 lock() 和 unlock()，若 unlock 未执行（如异常未捕获），将导致死锁。

3. 避免死锁

加锁虽能解决竞态条件，但不当使用可能引发死锁。以下是死锁的四个必要条件及规避策略：

（1）死锁的四个必要条件

互斥：资源同一时间只能被一个线程持有。
不可抢占：资源只能由持有者主动释放。
请求与保持：线程持有一个资源的同时请求其他资源。
循环等待：多个线程形成资源请求的环形依赖。

（2）规避策略

顺序加锁：约定全局加锁顺序（如先锁A再锁B）。

synchronized (lockA) {  
    synchronized (lockB) {  
        // 操作共享资源  
    }  
}

避免锁嵌套：减少锁的嵌套层级。

（3）死锁示例

// 线程1  
synchronized (lockA) {  
    synchronized (lockB) {  
        // 操作资源  
    }  
}  

// 线程2  
synchronized (lockB) {  
    synchronized (lockA) {  
        // 操作资源  
    }  
}

结果：线程1持有 lockA 请求 lockB，线程2持有 lockB 请求 lockA，形成死锁。

4. 解决内存可见性问题

强制线程每次访问变量时从主内存读取最新值，禁止编译器优化缓存。
代码示例：

private volatile boolean flag = false;  // 确保可见性  

// 线程A  
flag = true;  

// 线程B  
while (!flag) { /* 能感知flag变化 */ }

适用场景：单写多读（如标志位控制），不保证原子性。

5. 禁止指令重排序

volatile 修饰变量时，禁止 JVM 重排序相关指令。
示例：

// 共享变量  
volatile boolean flag = false;  // 添加 volatile 修饰
String data = null;  

// 线程1：初始化数据后设置标志位  
Thread t1 = new Thread(() -> {  
    data = "初始化完成";  // 步骤1：初始化数据  
    flag = true;         // 步骤2：设置标志位  
});  

// 线程2：等待标志位为 true 后使用数据  
Thread t2 = new Thread(() -> {  
    while (!flag) {  
        // 空循环等待  
    }  
    System.out.println(data.length());  // 预期 data 已初始化  
});