返回专栏
· 18 分钟阅读

线程安全与竞态条


一、什么是线程安全?

线程安全(Thread Safety)是指程序、对象或函数在多个线程同时访问时,仍然能够保持预期行为和数据正确性。

当多个线程同时访问共享资源时,如果没有适当的同步机制,就可能出现数据覆盖、状态不一致、结果错误等问题。

例如,两个线程同时对一个共享计数器执行自增操作:

class Counter {
    int count = 0;

    void increment() {
        count++;
    }
}

表面上,count++ 只是一个简单操作,但它通常包含多个步骤:

  1. 读取当前计数值。
  2. 将计数值加一。
  3. 将新值写回内存。

假设两个线程同时读取到 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 元取款,业务上应该拒绝其中一次。

问题不在于减法本身,而在于余额检查与余额更新不是一个不可分割的业务操作。

竞态条件的形成条件

竞态条件通常涉及以下因素:

  1. 多个线程或执行单元同时参与操作。
  2. 它们访问共同的状态或资源。
  3. 至少一个执行单元会修改该状态。
  4. 操作之间缺少足够的同步或协调。
  5. 执行顺序变化可能影响程序结果。

竞态条件不一定每次都会出现。它往往依赖特定的调度时机,因此可能在测试环境中长期无法复现,却在生产环境中偶发。

三、数据竞争与竞态条件的区别

数据竞争(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。
  • 两个线程都无法继续。

死锁通常需要同时满足四个条件:

  1. 互斥条件:资源不能被多个线程同时占用。
  2. 持有并等待:线程持有资源的同时等待其他资源。
  3. 不可剥夺:资源不能被强制抢占。
  4. 循环等待:线程之间形成循环资源依赖。

避免死锁的常见方法:

  • 统一锁的获取顺序。
  • 减少嵌套锁。
  • 缩小临界区。
  • 使用带超时的锁获取机制。
  • 避免持锁执行外部调用。

2. 活锁(Livelock)

活锁是指线程没有被阻塞,但由于不断响应彼此的状态变化,始终无法完成实际工作。

例如,两个线程不断检测到冲突后主动让步,又在下一次尝试时再次发生冲突。

活锁与死锁的区别:

对比维度 死锁 活锁
线程状态 阻塞等待 持续运行
CPU 使用 相关线程通常不再执行有效工作 可能持续消耗 CPU
状态变化 通常没有进展 不断变化但没有有效进展
解决方式 解除循环等待 引入随机退避、调整重试策略