返回专栏
· 19 分钟阅读

锁与原子操作


一、为什么需要锁与原子操作?

在多线程程序中,多个线程可能同时访问同一份共享数据。如果没有适当的同步机制,就可能出现数据竞争、更新丢失和状态不一致。

例如,两个线程同时执行计数器自增:

class Counter {
    int count = 0;

    void increment() {
        count++;
    }
}

看起来 count++ 只有一行代码,但它通常包含三个逻辑步骤:

  1. 读取当前值。
  2. 计算新值。
  3. 将新值写回。

假设初始值为 0,两个线程同时执行:

步骤 线程 A 线程 B count
1 读取 0 0
2 读取 0 0
3 计算 1 0
4 计算 1 0
5 写入 1 1
6 写入 1 1

最终结果是 1,而不是预期的 2。

这种问题称为更新丢失(Lost Update)。

锁与原子操作都可以解决这类并发更新问题,但它们采用不同的实现思路:

  • 锁(Lock):控制线程进入临界区的权限,使共享操作按照规定的同步规则执行。
  • 原子操作(Atomic Operation):保证特定操作具有不可分割的执行语义,避免其他线程观察到不完整的更新。

二、什么是锁(Lock)?

锁是一种并发同步机制,用于协调多个线程对共享资源的访问。

当一个线程获得锁之后,其他需要同一把锁的线程必须等待,直到锁被释放。

锁通常用于保护临界区(Critical Section)。

临界区是指访问或修改共享资源、必须遵守特定同步约束的代码区域。

例如:

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

这里使用 synchronized 保护计数器。

同一对象实例上的两个同步实例方法使用同一对象监视器锁,因此同一时刻只能有一个线程执行其中的同步区域。

1. 锁的基本工作原理

锁的基本执行过程:

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

锁的核心作用不只是阻止多个线程同时执行代码,还可以通过语言内存模型建立必要的内存同步关系。

例如,在 Java 中,对同一监视器的解锁操作 Happens-Before 后续线程对该监视器的加锁操作。这使前一个线程在释放锁之前完成的修改能够按照内存模型规定被后一个线程观察到。

2. 什么是临界区?

临界区是需要保护的共享状态访问区域。

例如银行账户:

class Account {
    private int balance = 1000;

    public synchronized boolean withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }
}

这里需要保护的不是单独的减法,而是整个业务操作:

  • 检查余额是否足够。
  • 扣减账户余额。
  • 返回操作结果。

如果只对 balance -= amount 加锁,而不保护前面的余额检查,仍然可能出现并发取款问题。

临界区的边界应由业务不变量决定,而不是简单按照代码行数决定。

3. 锁的基本属性

属性 含义
互斥性 同一把互斥锁通常只允许一个线程持有
可见性 正确的锁释放和获取可以建立内存同步关系
有序性 同步规则限制相关操作的重排序
阻塞或等待 获取不到锁的线程可能等待
资源管理 锁需要正确获取、释放和管理生命周期

需要注意,不同锁的实现和语义并不完全相同。例如,自旋锁可能不会立即阻塞线程,而是让线程持续尝试获取锁。

三、锁的常见类型

不同场景需要不同的锁机制。选择锁时,需要考虑并发读写比例、临界区大小、竞争程度以及公平性要求。

1. 互斥锁(Mutex)

互斥锁(Mutual Exclusion Lock)是最常见的同步机制。

它保证同一时刻只有一个线程能够持有锁。

例如 C++:

#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 创建互斥锁。
  • lock_guard 在构造时获取锁。
  • 离开作用域时自动释放锁。
  • counter++ 在锁保护下执行。

互斥锁适合:

  • 共享变量更新。
  • 账户余额修改。
  • 共享容器操作。
  • 多字段状态维护。
  • 需要保护完整业务操作的场景。

2. 可重入锁(Reentrant Lock)

可重入锁允许已经持有锁的线程再次获取同一把锁。

例如 Java:

import java.util.concurrent.locks.ReentrantLock;

class Service {
    private final ReentrantLock lock = new ReentrantLock();

    public void methodA() {
        lock.lock();
        try {
            methodB();
        } finally {
            lock.unlock();
        }
    }

    public void methodB() {
        lock.lock();
        try {
            System.out.println("执行方法 B");
        } finally {
            lock.unlock();
        }
    }
}

线程执行 methodA() 时已经获得锁,调用 methodB() 后,同一线程可以再次获取这把锁。

可重入锁通常会记录持有线程和重入次数。

每次成功获取锁都会增加持有计数,只有对应次数的释放完成后,锁才真正变为可用状态。

适合:

  • 递归调用。
  • 多层方法调用。
  • 同一对象内部方法之间存在锁嵌套的场景。

但可重入并不意味着可以忽略锁设计。它仍然可能发生死锁,也不能解决不同线程之间的资源循环等待。

3. 读写锁(Read-Write Lock)

读写锁将访问操作分为读取和写入两类。

通常具有以下规则:

  • 多个线程可以同时持有读锁。
  • 写锁需要独占访问。
  • 写锁通常不能与其他读锁或写锁同时持有。

例如 Java:

import java.util.concurrent.locks.ReentrantReadWriteLock;

class Cache {
    private final ReentrantReadWriteLock lock =
        new ReentrantReadWriteLock();

    private String value = "initial";

    public String read() {
        lock.readLock().lock();
        try {
            return value;
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write(String newValue) {
        lock.writeLock().lock();
        try {
            value = newValue;
        } finally {
            lock.writeLock().unlock();
        }
    }
}

读写锁适合读多写少的场景,例如:

  • 配置中心缓存。
  • 元数据读取。
  • 只读索引。
  • 共享字典。

但读写锁并不一定比普通互斥锁快。

当写操作较多、临界区很短或锁竞争不明显时,读写锁的管理成本可能抵消并发读取带来的收益。

4. 自旋锁(Spinlock)

自旋锁是一种线程在获取锁失败后持续循环尝试的锁机制。

典型逻辑:

while (lock_is_busy()) {
    // 持续尝试
}

acquire_lock();

与阻塞锁不同,自旋锁通常不会让线程立即进入睡眠等待,而是持续检查锁状态。

优点:

  • 避免某些情况下线程阻塞和唤醒的开销。
  • 适合临界区非常短的场景。
  • 在多核环境下可能具有较低的获取延迟。

缺点:

  • 等待期间持续消耗 CPU。
  • 临界区过长时性能可能很差。
  • 单核或 CPU 资源紧张时可能产生严重竞争。

自旋锁更适合短时间持锁、竞争可控的场景。

5. 公平锁与非公平锁

公平性描述多个等待线程获取锁时的调度策略。

公平锁:

通常按照等待顺序分配锁,减少某些线程长期得不到锁的风险。

非公平锁:

允许新到达的线程参与竞争,可能提高吞吐量,但等待时间不一定公平。

例如 Java:

ReentrantLock fairLock = new ReentrantLock(true);
ReentrantLock unfairLock = new ReentrantLock(false);

公平锁不代表绝对公平,也不代表一定不会发生饥饿。实际行为仍受调度器、锁实现和系统负载影响。

6. 锁类型对比

锁类型 核心特点 典型场景
互斥锁 同一时刻一个线程持有 通用共享状态保护
可重入锁 同一线程可重复获取 嵌套调用、递归
读写锁 允许并发读取,写入独占 读多写少
自旋锁 持续尝试获取锁 极短临界区
公平锁 尽量按照等待顺序分配 关注等待公平性
非公平锁 允许竞争插队 关注吞吐量

四、什么是原子操作(Atomic Operation)?

原子操作是指在并发语义上不可分割的操作。

一个原子操作要么完整地完成,要么不产生部分完成的可观察结果。

例如:

AtomicInteger counter = new AtomicInteger(0);

counter.incrementAndGet();

这里的自增操作由原子类提供,不会因为多个线程同时执行而产生普通读改写导致的更新丢失。

原子操作的关键不在于代码只有一行,而在于操作本身受到语言内存模型和底层实现的原子性保证。

1. 原子操作与普通操作的区别

普通自增:

int count = 0;
count++;

原子自增:

AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();

两者的差异:

对比维度 普通自增 原子自增
操作语义 读、计算、写 不可分割的原子更新
并发安全 需要额外同步 特定原子更新操作可并发安全
更新丢失 可能发生 不会因该原子操作发生
实现方式 普通内存访问 原子指令、CAS 或其他机制
适用范围 单线程或已有同步保护 适合简单共享状态更新

2. 原子操作的基本特点

不可分割性

其他线程不能观察到原子更新操作的中间状态。

线性化语义

许多原子操作可以被理解为在某个瞬间完成,仿佛多个线程的操作按照某个合法顺序依次发生。

并发安全

在正确使用原子操作的前提下,可以避免特定共享变量更新中的数据竞争。

不一定无锁

原子操作不代表底层实现一定没有锁。某些平台或类型可能通过内部锁实现原子语义。

五、CAS:原子操作的核心机制之一

CAS(Compare-And-Swap,比较并交换)是一种常见的原子更新机制。

它通常涉及三个值:

  • V:当前内存中的值。
  • A:预期的旧值。
  • B:希望写入的新值。

CAS 的执行规则:

  1. 读取当前值 V。
  2. 比较 V 是否等于预期值 A。
  3. 如果相等,将 V 更新为 B。
  4. 如果不相等,则不更新。
  5. 返回操作是否成功。

1. CAS 的执行过程

flowchart TD
    A["读取当前值 V"] --> B["准备预期值 A 和新值 B"]
    B --> C["执行 CAS"]
    C --> D{"V 是否等于 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 的关键是比较与更新必须作为一个原子操作完成。

如果两个线程同时尝试将同一个值从 0 更新为 1:

  • 线程 A 的 CAS 成功。
  • 线程 B 的预期值已经不再匹配。
  • 线程 B 的 CAS 失败。
  • 线程 B 可以重新读取并计算新值。

这样就避免了两个线程无条件覆盖彼此的更新。

2. Java 中的 CAS

Java 提供了多种原子类:

import java.util.concurrent.atomic.AtomicInteger;

class Counter {
    private final AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int get() {
        return count.get();
    }
}

常见原子类包括:

类型 作用
AtomicInteger 原子整数
AtomicLong 原子长整数
AtomicBoolean 原子布尔值
AtomicReference 原子对象引用
AtomicIntegerArray 原子整数数组
LongAdder 面向高并发累加场景的计数器

AtomicInteger 常用于简单计数器,LongAdder 则适合高竞争下的统计累加。两者在读取语义和性能特征上有所不同,不能完全互换。

3. CAS 的 ABA 问题

CAS 有一个经典问题:ABA(ABA Problem)。

假设一个变量初始值为 A:

  1. 线程 A 读取到 A。
  2. 线程 B 将 A 修改为 B。
  3. 线程 B 又将 B 修改回 A。
  4. 线程 A 执行 CAS,发现当前值仍然是 A。
  5. CAS 成功。

线程 A 无法仅通过当前值判断变量是否曾经发生过变化。

如果业务要求识别中间状态变化,这就可能产生问题。

解决思路之一是使用版本号或时间戳。

例如 Java:

import java.util.concurrent.atomic.AtomicStampedReference;

class Example {
    private final AtomicStampedReference<String> reference =
        new AtomicStampedReference<>("A", 0);

    public void update() {
        int[] stamp = new int[1];

        String value = reference.get(stamp);

        reference.compareAndSet(
            value,
            "B",
            stamp[0],
            stamp[0] + 1
        );
    }
}

这里除了比较对象引用,还会比较版本戳。

即使对象引用从 A 变成 B 再回到 A,版本戳也可以帮助识别状态变化。

六、锁与原子操作的区别

锁与原子操作都能用于并发同步,但适用范围不同。

对比维度 锁 原子操作
核心机制 控制临界区访问权限 保证特定操作不可分割
保护范围 可以保护多个变量和复合操作 通常针对特定变量或有限状态
线程等待 可能阻塞,也可能自旋 具体实现可能重试或使用内部锁
实现方式 锁状态、调度和内存同步 原子指令、CAS 等
编程复杂度 锁范围和生命周期需要管理 复杂状态更新可能需要重试逻辑
常见用途 多字段状态、业务事务式操作 计数器、标志位、简单状态更新

1. 锁适合复杂操作

例如银行账户取款:

class Account {
    private int balance = 1000;

    public synchronized boolean withdraw(int amount) {
        if (balance < amount) {
            return false;
        }

        balance -= amount;
        return true;
    }
}

这里需要将检查余额和扣减余额作为一个整体保护。

如果只使用两个独立的原子操作,仍然可能出现逻辑竞态。

2. 原子操作适合简单状态更新

例如共享计数器:

AtomicInteger counter = new AtomicInteger(0);

counter.incrementAndGet();

对于简单的单变量更新,原子类通常比手动管理互斥锁更直接。

3. 二者并不是完全对立的

实际系统中,锁内部也可能使用原子操作维护锁状态。

例如:

  • 使用 CAS 竞争锁。
  • 使用原子变量维护等待队列。
  • 使用内存屏障建立同步关系。
  • 竞争激烈时通过操作系统等待机制挂起线程。

因此,锁与原子操作不是两种完全独立的底层技术。它们在不同抽象层次上解决并发问题。

七、原子性、可见性与有序性

理解锁与原子操作,还需要区分并发编程中的三个核心概念。

1. 原子性(Atomicity)

原子性关注一个操作是否具有不可分割的执行语义。

例如:

AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();

自增操作具有原子更新语义。

但以下操作:

if (count.get() > 0) {
    count.decrementAndGet();
}

整体并不具备原子性。

因为读取和递减是两个独立操作,其他线程可能在中间改变计数值。

2. 可见性(Visibility)

可见性关注一个线程的修改能否被其他线程按照内存模型规定观察到。

例如 Java:

volatile boolean running = true;

一个线程修改 running 后,其他线程读取该变量时,可以获得 Java 内存模型规定的可见性保证。

但 volatile 不会让复合操作自动变成原子操作。

3. 有序性(Ordering)

有序性关注操作之间的执行顺序是否满足程序和内存模型的要求。

编译器和 CPU 可能进行指令重排,但不能破坏语言内存模型所规定的同步约束。

例如,Java 中对同一把监视器锁的解锁与后续加锁之间存在 Happens-Before 关系。

4. 三者之间的关系

概念 解决的问题 常见机制
原子性 操作是否不可分割 锁、CAS、原子指令
可见性 修改能否被其他线程观察 锁、volatile、原子变量
有序性 操作是否满足必要顺序约束 锁、volatile、内存屏障

这三个概念相互关联,但不能互相替代。

例如,Java 的 volatile 可以提供可见性和特定的有序性保证,却不能保证 count++ 这样的复合操作具有原子性。

八、锁与原子操作的底层实现

锁和原子操作通常依赖处理器提供的原子指令、内存屏障以及操作系统的线程调度能力。

1. CPU 原子指令

现代处理器通常提供专门的原子操作指令或指令组合。

例如:

  • x86 的 LOCK 前缀相关指令。
  • ARM 的 Load-Exclusive / Store-Exclusive 指令族。
  • ARM 的部分原子读改写指令。
  • 处理器提供的比较交换或其他原子读改写能力。

这些机制可以支持底层原子操作的实现。

但不同处理器架构的指令和内存顺序保证不同,不能简单认为所有平台都通过同一种指令实现 CAS。

2. 内存屏障(Memory Barrier)

内存屏障用于约束特定内存操作的重排序,并帮助实现语言内存模型要求的同步语义。

常见概念包括:

屏障类型 主要作用
Load Barrier 对读取操作建立顺序约束
Store Barrier 对写入操作建立顺序约束
Full Barrier 对读写操作建立更强的顺序约束

实际指令和屏障语义取决于处理器架构及语言运行时。

程序员通常应优先使用语言提供的同步原语,而不是自行编写底层屏障代码。

3. 锁的底层实现

以常见的互斥锁为例,内部可能涉及:

  • 原子变量维护锁状态。
  • CAS 竞争锁。
  • 维护等待线程队列。
  • 竞争失败后执行自旋或阻塞。
  • 锁释放后唤醒等待线程。

并不是所有锁都一定使用操作系统互斥量,也不是所有锁竞争都会立即导致线程进入内核态。

4. 锁与原子操作的底层关系

flowchart TD
    A["并发同步需求"] --> B["锁机制"]
    A --> C["原子操作"]
    B --> D["原子状态更新"]
    B --> E["等待队列与线程调度"]
    B --> F["内存同步约束"]
    C --> G["CPU 原子指令"]
    C --> H["CAS 或原子读改写"]
    C --> I["内存顺序约束"]
    D --> J["实现互斥与状态管理"]
    E --> J
    F --> K["建立正确同步关系"]
    G --> L["完成不可分割更新"]
    H --> L
    I --> K

    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:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style L fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px