一、什么是线程安全?
线程安全(Thread Safety)是指程序、对象或函数在多个线程同时访问时,仍然能够保持预期行为和数据正确性。
当多个线程同时访问共享资源时,如果没有适当的同步机制,就可能出现数据覆盖、状态不一致、结果错误等问题。
例如,两个线程同时对一个共享计数器执行自增操作:
class Counter {
int count = 0;
void increment() {
count++;
}
}
表面上,count++ 只是一个简单操作,但它通常包含多个步骤:
- 读取当前计数值。
- 将计数值加一。
- 将新值写回内存。
假设两个线程同时读取到 count = 0:
- 线程 A 读取 0。
- 线程 B 读取 0。
- 线程 A 计算得到 1。
- 线程 B 计算得到 1。
- 线程 A 写入 1。
- 线程 B 写入 1。
最终结果是 1,而不是预期的 2。
这种情况称为更新丢失(Lost Update),是并发程序中常见的数据竞争问题。
线程安全的核心目标
线程安全通常需要保证以下性质:
| 性质 | 含义 |
|---|---|
| 原子性(Atomicity) | 关键操作不可被其他线程观察到中间状态 |
| 可见性(Visibility) | 一个线程的修改能够按照内存模型规定被其他线程观察到 |
| 有序性(Ordering) | 操作之间的执行顺序符合程序要求和内存模型约束 |
| 状态一致性 | 并发访问不会破坏对象或数据结构的不变量 |
| 线程隔离 | 不同线程的操作不会产生不符合预期的干扰 |
需要注意,原子性、可见性和有序性是并发编程中常用的三个核心概念,但它们并不能单独覆盖所有线程安全问题。例如,即使每次单独操作都是原子的,多个操作组合起来仍可能出现逻辑错误。
二、什么是竞态条件?
竞态条件(Race Condition)是指程序的正确结果依赖多个执行单元之间不可控的执行时序,而这种时序变化可能导致错误结果。
多个线程同时访问共享数据时,如果执行顺序不同,程序可能产生不同结果。
例如:
class BankAccount {
int balance = 1000;
void withdraw(int amount) {
if (balance >= amount) {
balance -= amount;
}
}
}
假设账户余额为 1000,两个线程同时取款 800。
可能出现以下执行顺序:
| 执行步骤 | 线程 A | 线程 B | 余额 |
|---|---|---|---|
| 1 | 读取余额 1000 | 1000 | |
| 2 | 读取余额 1000 | 1000 | |
| 3 | 判断余额足够 | 1000 | |
| 4 | 判断余额足够 | 1000 | |
| 5 | 写入余额 200 | 200 | |
| 6 | 写入余额 200 | 200 |
最终余额为 200,但实际上发生了两次 800 元取款,业务上应该拒绝其中一次。
问题不在于减法本身,而在于余额检查与余额更新不是一个不可分割的业务操作。
竞态条件的形成条件
竞态条件通常涉及以下因素:
- 多个线程或执行单元同时参与操作。
- 它们访问共同的状态或资源。
- 至少一个执行单元会修改该状态。
- 操作之间缺少足够的同步或协调。
- 执行顺序变化可能影响程序结果。
竞态条件不一定每次都会出现。它往往依赖特定的调度时机,因此可能在测试环境中长期无法复现,却在生产环境中偶发。
三、数据竞争与竞态条件的区别
数据竞争(Data Race)与竞态条件(Race Condition)经常被混用,但两者并不完全相同。
1. 数据竞争(Data Race)
数据竞争通常指多个执行线程并发访问同一内存位置,其中至少一个访问是写操作,并且访问之间没有满足语言内存模型要求的同步关系。
例如:
#include <thread>
#include <iostream>
int counter = 0;
void increment() {
counter++;
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << counter << std::endl;
}
在 C++ 中,两个线程对普通非原子变量 counter 并发执行读写操作,构成数据竞争,程序行为未定义(Undefined Behavior)。
这里不能简单认为结果一定是 1 或 2。对于存在数据竞争的 C++ 程序,编译器优化和语言内存模型都可能使行为超出直观预期。
2. 竞态条件(Race Condition)
竞态条件的范围更广。
它关注的是:程序的正确性是否依赖执行时序。
竞态条件既可能来自内存数据竞争,也可能来自多个操作之间的逻辑时序问题。
例如:
if (!file.exists()) {
createFile();
}
两个线程可能同时判断文件不存在,然后同时尝试创建文件。
即使文件系统操作本身具有一定原子性,检查和创建仍然是两个独立操作,组合起来存在竞态窗口。
这种问题通常称为检查与执行之间的竞态(TOCTOU,Time Of Check To Time Of Use)。
3. 两者的区别
| 对比维度 | 数据竞争 | 竞态条件 |
|---|---|---|
| 关注重点 | 内存访问与同步关系 | 执行时序对结果的影响 |
| 是否涉及共享数据 | 通常涉及共享内存位置 | 不一定局限于内存变量 |
| 是否必须包含写操作 | 通常至少有一个写操作 | 不一定表现为普通内存读写冲突 |
| 是否可能导致未定义行为 | 取决于语言内存模型;C++ 中数据竞争导致未定义行为 | 不一定 |
| 典型问题 | 无同步地读写共享变量 | 重复扣款、重复创建、状态检查失效 |
可以这样理解:
- 数据竞争是一类具体的并发访问问题。
- 竞态条件是一类更广泛的时序依赖问题。
- 数据竞争可能导致竞态条件,但竞态条件并不一定包含数据竞争。
四、竞态条件的常见类型
1. 更新丢失(Lost Update)
多个线程同时读取同一个旧值,分别计算新值,最后写入时互相覆盖。
counter++;
两个线程同时执行自增,可能导致其中一次更新丢失。
典型场景:
- 账户余额更新。
- 库存数量修改。
- 共享计数器。
- 统计数据累加。
2. 脏读或中间状态读取
一个线程正在修改多个相关字段,另一个线程在修改完成之前读取了部分状态。
例如:
class User {
String name;
int age;
}
线程 A 更新用户信息时:
user.name = "Alice";
user.age = 30;
线程 B 可能在两次赋值之间读取数据,得到新姓名和旧年龄。
如果业务要求两个字段必须保持一致,就需要同步保护整个状态更新过程。
3. 检查与执行竞态(TOCTOU)
程序先检查某个条件,再根据检查结果执行操作。
如果两个操作之间共享状态发生变化,之前的检查结果就可能失效。
例如:
if path.exists():
with open(path, "w") as file:
file.write("data")
文件状态可能在检查与打开之间发生变化。
对于文件操作,通常应优先采用操作系统提供的原子创建、独占打开等机制,而不是依赖先检查再执行。
4. 竞态初始化(Initialization Race)
多个线程同时发现某个对象尚未初始化,然后重复执行初始化逻辑。
if (instance == null) {
instance = new Service();
}
两个线程可能同时通过 instance == null 判断,从而创建两个实例。
对于单例对象、连接池、配置加载器等共享资源,初始化过程需要正确同步。
5. 任务完成顺序竞态
多个异步任务同时执行,完成顺序与启动顺序不同。
例如:
async function main() {
const a = fetchDataA();
const b = fetchDataB();
const resultA = await a;
const resultB = await b;
}
两个请求可能以任意顺序完成。
如果后完成的旧请求覆盖了先完成的新请求结果,就可能出现界面状态回退等问题。
这类问题不一定是传统意义上的内存数据竞争,但仍然属于需要管理执行时序的并发问题。
五、线程安全的实现机制
解决线程安全问题,核心是控制共享状态的访问方式,确保多个执行单元之间具有正确的协调关系。
1. 互斥锁(Mutex)
互斥锁用于保护临界区,确保同一时刻只有一个线程能够持有锁并执行受保护的代码。
#include <iostream>
#include <mutex>
#include <thread>
int counter = 0;
std::mutex mtx;
void increment() {
std::lock_guard<std::mutex> lock(mtx);
counter++;
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << counter << std::endl;
}
这里通过 std::mutex 保护共享变量,通过 std::lock_guard 自动管理锁的生命周期。
核心思想是:
- 进入临界区之前获取锁。
- 获取成功后执行共享数据操作。
- 离开作用域时释放锁。
- 其他线程等待锁释放后再进入临界区。
互斥锁能够保护复合操作,而不只是单个变量的读写。
2. 锁保护的执行流程
flowchart TD
A["线程请求访问共享资源"] --> B["尝试获取互斥锁"]
B --> C{"是否获取成功"}
C -->|"否"| D["等待锁释放"]
D --> B
C -->|"是"| E["进入临界区"]
E --> F["读取或修改共享数据"]
F --> G["退出临界区"]
G --> H["释放互斥锁"]
H --> I["其他线程可以获取锁"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
style D fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
使用互斥锁时,需要注意:
- 锁的范围应覆盖完整的共享状态操作。
- 不要在持锁期间执行不必要的耗时操作。
- 所有访问同一受保护状态的代码都必须遵守相同的锁协议。
- 必须确保异常或提前返回时锁仍然能够释放。
3. 读写锁(Read-Write Lock)
读写锁允许多个线程同时读取共享数据,但写操作需要独占访问。
典型规则:
- 多个读线程可以同时持有读锁。
- 写线程需要独占写锁。
- 写锁通常不能与其他读锁或写锁同时持有。
- 具体的公平性和读写优先策略取决于实现。
适用于读操作远多于写操作的场景,例如:
- 配置读取。
- 缓存查询。
- 元数据访问。
- 只读索引。
但读写锁并不一定比互斥锁更快。它的状态管理更复杂,可能带来额外开销,也可能产生写线程饥饿问题。
4. 原子操作(Atomic Operations)
原子操作能够保证特定操作在并发环境下具有不可分割的语义。
例如 C++:
#include <atomic>
#include <thread>
#include <iostream>
std::atomic<int> counter{0};
void increment() {
counter.fetch_add(1);
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << counter.load() << std::endl;
}
fetch_add() 能够原子地完成读取、增加和写回。
原子操作通常适合:
- 计数器。
- 标志位。
- 状态切换。
- 简单共享统计。
- 无锁数据结构中的部分底层操作。
但原子变量不意味着所有复合业务逻辑自动安全。
例如:
if (balance.get() >= amount) {
balance.addAndGet(-amount);
}
即使 get() 和 addAndGet() 分别是原子操作,整个检查与扣减过程仍然不是原子操作。
可以使用 CAS 循环:
import java.util.concurrent.atomic.AtomicInteger;
class Account {
private final AtomicInteger balance = new AtomicInteger(1000);
boolean withdraw(int amount) {
while (true) {
int current = balance.get();
if (current < amount) {
return false;
}
int next = current - amount;
if (balance.compareAndSet(current, next)) {
return true;
}
}
}
}
这里通过比较并交换(Compare-And-Swap,CAS)保证余额检查与更新具有原子性。
5. CAS(Compare-And-Swap)
CAS 是一种常见的原子更新机制。
它通常包含三个核心参数:
- V:当前内存中的值。
- A:预期的旧值。
- B:准备写入的新值。
执行规则:
- 如果 V 等于 A,则将 V 更新为 B。
- 如果 V 不等于 A,则更新失败。
- 返回操作是否成功,供调用方决定是否重试。
CAS 的基本流程:
flowchart TD
A["读取当前值 V"] --> B["计算新值 B"]
B --> C["执行 CAS"]
C --> D{"当前值是否等于预期值 A"}
D -->|"是"| E["写入新值 B"]
E --> F["操作成功"]
D -->|"否"| G["更新失败"]
G --> H["重新读取当前值"]
H --> B
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#FBE9E9,stroke:#D9AAAA,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
CAS 的优势是避免传统互斥锁的显式阻塞,但它也存在局限:
- 高竞争下可能产生大量重试。
- 复杂状态更新可能难以表达。
- 需要注意 ABA 问题。
- 原子性与内存可见性、内存顺序是不同层面的保证。
6. 不可变对象(Immutable Object)
不可变对象创建后,其内部状态不能被修改。
如果多个线程只读取不可变对象,就不需要为对象状态的修改设置互斥锁,因为不存在并发修改。
例如:
public final class User {
private final String name;
private final int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
不可变对象的优势:
- 不存在对象内部状态的并发修改。
- 更容易共享。
- 更容易测试和推理。
- 可以减少锁的使用。
- 有助于构建函数式并发程序。
但不可变对象需要注意深层不可变性。如果对象内部持有可变集合或可变引用,仅仅将字段声明为 final,并不能保证整个对象完全不可变。
六、内存可见性与内存模型
线程安全不仅涉及原子性,还涉及一个线程的修改能否被另一个线程正确观察到。
1. 什么是内存可见性?
现代 CPU 和编译器会进行缓存、指令重排和优化,以提高执行效率。
因此,一个线程修改共享变量后,另一个线程不一定能够立即观察到修改。
例如 Java:
class Worker {
boolean running = true;
void work() {
while (running) {
// 执行任务
}
}
void stop() {
running = false;
}
}
如果没有正确的同步关系,工作线程可能无法按预期观察到 running 的修改。
一种解决方式是使用 volatile:
class Worker {
volatile boolean running = true;
void work() {
while (running) {
// 执行任务
}
}
void stop() {
running = false;
}
}
Java 的 volatile 可以为该变量提供可见性和特定的有序性保证,但不能保证复合操作的原子性。
例如:
volatile int count = 0;
count++;
count++ 仍然不是原子操作。
2. Happens-Before 关系
Happens-Before 是并发内存模型中的重要概念,用来描述操作之间必须满足的可见性和顺序约束。
如果操作 A Happens-Before 操作 B,那么:
- A 的效果必须对 B 按照内存模型规定可见。
- A 和 B 之间存在相应的顺序约束。
- 编译器和处理器不能以破坏该关系的方式进行优化。
Java 中常见的 Happens-Before 规则包括:
| 规则 | 含义 |
|---|---|
| 程序顺序规则 | 同一线程中,程序顺序靠前的操作 Happens-Before 后续操作 |
| 监视器锁规则 | 对同一把锁的解锁 Happens-Before 后续加锁 |
| volatile 规则 | 对 volatile 变量的写 Happens-Before 后续对该变量的读 |
| 线程启动规则 | 对线程调用 start() Happens-Before 被启动线程中的操作 |
| 线程终止规则 | 线程中的操作 Happens-Before 其他线程成功检测到该线程终止 |
| 传递性规则 | A Happens-Before B,B Happens-Before C,则 A Happens-Before C |
这些规则是 Java 内存模型中的具体规则,不应直接当作所有语言的统一内存模型。
3. 内存可见性的示意
flowchart TD
A["线程 A"] --> B["写入共享变量"]
B --> C["释放同步锁"]
C --> D["建立 Happens-Before 关系"]
E["线程 B"] --> F["获取同一把同步锁"]
F --> G["读取共享变量"]
D --> G
G --> H["观察到符合内存模型的修改结果"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
这里的关键不是简单地认为“写入主内存后其他线程就能读取”,而是通过语言内存模型规定的同步关系建立正确的可见性保证。
七、锁的常见问题
锁能够解决共享状态访问问题,但使用不当也会引入新的并发故障。
1. 死锁(Deadlock)
死锁是指多个线程互相等待对方持有的资源,导致所有相关线程都无法继续执行。
例如:
synchronized (lockA) {
synchronized (lockB) {
// 操作
}
}
另一个线程:
synchronized (lockB) {
synchronized (lockA) {
// 操作
}
}
可能出现:
- 线程 A 持有
lockA,等待lockB。 - 线程 B 持有
lockB,等待lockA。 - 两个线程都无法继续。
死锁通常需要同时满足四个条件:
- 互斥条件:资源不能被多个线程同时占用。
- 持有并等待:线程持有资源的同时等待其他资源。
- 不可剥夺:资源不能被强制抢占。
- 循环等待:线程之间形成循环资源依赖。
避免死锁的常见方法:
- 统一锁的获取顺序。
- 减少嵌套锁。
- 缩小临界区。
- 使用带超时的锁获取机制。
- 避免持锁执行外部调用。
2. 活锁(Livelock)
活锁是指线程没有被阻塞,但由于不断响应彼此的状态变化,始终无法完成实际工作。
例如,两个线程不断检测到冲突后主动让步,又在下一次尝试时再次发生冲突。
活锁与死锁的区别:
| 对比维度 | 死锁 | 活锁 |
|---|---|---|
| 线程状态 | 阻塞等待 | 持续运行 |
| CPU 使用 | 相关线程通常不再执行有效工作 | 可能持续消耗 CPU |
| 状态变化 | 通常没有进展 | 不断变化但没有有效进展 |
| 解决方式 | 解除循环等待 | 引入随机退避、调整重试策略 |