操作系统 / 技术文章

一文搞懂锁:线程锁、文件锁、数据库锁与分布式锁

并发问题真正难的地方,不是记住几十个“锁”的名字,而是判断竞争发生在哪一层、锁保护的资源是什么、失败时应该等待还是重试。面向 Java 后端和服务端开发,这篇长文从线程、进程、数据库事务一路讲到多节点服务,最终建立一套可用于真实项目的锁选型框架。

先把锁放回正确的坐标系

很多资料会把互斥锁、可重入锁、公平锁、行锁、乐观锁、Redis 锁平铺在一张清单里,看起来像几十种互不相关的锁。真正的问题是:这些词并不处于同一个分类维度。

理解锁至少需要同时看两个坐标。

第一个坐标是作用范围,也就是“谁和谁在竞争”:

  • 同一个 JVM 内的多个线程;
  • 同一台机器上的多个进程;
  • 同一个数据库中的多个事务;
  • 多台机器、多个容器或多个服务实例。

第二个坐标是并发语义,也就是“竞争发生后怎么办”:

  • 互斥还是共享;
  • 可重入还是不可重入;
  • 公平还是非公平;
  • 悲观还是乐观;
  • 阻塞等待、自旋,还是失败后重试。

锁的作用范围与语义维度

例如 ReentrantLock 本身是一种 JVM 内线程锁,同时又具备互斥、可重入等特征,并且可以配置为公平或非公平。所谓“公平锁”不是和 ReentrantLock 并列的另一套技术,而是在描述它的一种行为属性。

同样,数据库里的“行锁”和“乐观锁”也不是同一层面的两个选项。行锁描述的是数据库内部锁住什么粒度的资源;乐观锁描述的是业务更新时采用什么冲突检测策略。

线程锁解决的是一个进程里的共享状态

当多个线程运行在同一个 JVM 中,并且会访问同一份可变状态时,线程锁才真正开始有意义。最典型的临界区,就是“读取旧值、计算新值、写回结果”这一段不能被其他线程打断。

例如两个线程同时执行 count++。这个表达式看起来只有一行,但底层不是不可分割的一步,它至少包含读取、加一、写回。如果两个线程交错执行,就可能出现丢失更新。

synchronized 与 ReentrantLock

Java 中最常见的两个互斥手段是 synchronized 和 ReentrantLock。

synchronized 的优势是语义直接,进入同步块时自动加锁,退出时自动释放,不容易因为异常路径漏掉 unlock。如果需求只是保护一个简单临界区,它往往是第一选择。

ReentrantLock 则提供了更显式的控制,例如:

  • 尝试获取锁而不是永久等待;
  • 可中断地等待锁;
  • 配置公平策略;
  • 使用多个 Condition 做更精细的等待与通知。

下面的完整示例用 ReentrantLock 保护共享计数器:

java
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
    private static final ReentrantLock LOCK = new ReentrantLock();
    private static int count = 0;

    private static void increase() {
        LOCK.lock();
        try {
            count++;
        } finally {
            // 锁必须放在 finally 中释放,避免异常路径遗留锁。
            LOCK.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 100_000; i++) {
                increase();
            }
        };

        Thread t1 = new Thread(task, "worker-1");
        Thread t2 = new Thread(task, "worker-2");

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

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

        System.out.println(count);
    }
}

预期输出:

text
200000

这个例子真正说明的不是“ReentrantLock 会让结果正确”,而是对共享变量的复合修改必须放进同一个互斥边界中。

线程竞争与临界区

读写锁、Semaphore 和 CAS 不是“更高级的 Mutex”

如果访问模式是“读很多、写很少”,让所有读线程彼此互斥会浪费并发能力。这时 ReadWriteLock 才有意义:多个读者可以同时进入,但写者需要独占。

如果问题不是“只能一个进入”,而是“最多允许 N 个同时进入”,应该考虑 Semaphore。例如一个第三方接口只允许最多 20 个并发请求,那么信号量表达的是配额,而不是互斥。

CAS 则是另一条路线。它不一定先把其他线程挡在门外,而是比较“当前值是否仍然等于我刚才看到的旧值”,只有比较成功才提交修改。这类思路广泛存在于 AtomicInteger、无锁数据结构和数据库 version 乐观锁中。

文件锁解决同一台机器上的多进程竞争

线程锁依赖进程内部的内存状态。两个进程拥有不同的地址空间,所以 JVM A 中的 ReentrantLock 根本看不到 JVM B。

如果多个脚本、Worker 或独立进程运行在同一台机器上,并且需要争夺同一份本地资源,文件锁就是一种常见选择。Linux/Unix 下经常会看到 flock 和 fcntl。

典型场景包括:

  • 定时任务防止重叠执行;
  • 单机多个 Worker 防止同时处理同一个本地任务;
  • 本地缓存或索引文件写入互斥;
  • 保证一个桌面程序只启动一个实例。

下面这个命令尝试非阻塞地获取文件锁:

bash
flock -n /tmp/anystack-job.lock -c 'printf "job started\n"; sleep 2'

预期输出:

text
job started

如果同一时刻另一个进程已经持有这把锁,新的 flock -n 调用会立即失败而不是继续等待,通常没有标准输出,并返回非零退出码。

这里有一个很重要的区别:锁文件和文件锁不是一回事。

仅仅创建 /tmp/anystack-job.lock,然后用“文件存在即认为有人运行”的逻辑,并不可靠。进程如果异常退出,文件仍可能残留,后续任务会误认为锁一直存在。

真正的文件锁通常由操作系统内核维护。进程结束、文件描述符关闭后,对应锁状态也会随之释放,因此不会单纯因为那个路径还存在就永久占锁。

文件锁还有一个天然边界:它只适合能够共享同一套内核锁状态的进程。两台不同服务器各自都有 /tmp/anystack-job.lock,这两个路径看起来相同,实际却是两份完全独立的锁。

数据库锁保护的是事务里的数据一致性

进入数据库以后,锁的讨论会明显变复杂,因为数据库不仅有“要不要锁”,还有锁粒度、索引、隔离级别、事务持续时间等多个因素。

理解数据库锁时,至少要区分三组概念:

  • 锁粒度:表锁、页锁、行锁;
  • 数据库内部锁类型:例如 MySQL InnoDB 中的 Record Lock、Gap Lock、Next-Key Lock;
  • 业务并发策略:悲观锁、乐观锁。

悲观锁:先锁住再修改

悲观锁的出发点是“冲突很可能发生”,因此先阻止其他事务修改目标数据。

下面是一个片段示例,假设已经存在 orders(id, status, version) 表,并且 SQL 运行在显式事务中:

sql
START TRANSACTION;

SELECT id, status, version
FROM orders
WHERE id = 1001
FOR UPDATE;

UPDATE orders
SET status = 'PAID'
WHERE id = 1001;

COMMIT;

预期结果:

text
当前事务在提交前持有冲突锁;其他尝试锁定或修改同一目标记录的事务可能等待。

这里不能简单理解成“FOR UPDATE 永远只锁一行”。实际锁范围受数据库产品、索引命中方式、隔离级别和查询条件影响。尤其在 MySQL InnoDB 中,范围查询可能涉及记录锁、间隙锁或 Next-Key Lock。

乐观锁:提交时再确认别人有没有改过

乐观锁更适合冲突概率较低、失败后可以重试的场景。最常见的做法是增加 version 字段:

sql
UPDATE orders
SET status = 'PAID',
    version = version + 1
WHERE id = 1001
  AND version = 3;

预期结果:

text
version 仍为 3:受影响行数 = 1
version 已变化:受影响行数 = 0

受影响行数为 0,不表示数据库坏了,而是告诉业务层:你看到的旧版本已经过期,需要重新读取、合并或放弃本次操作。

数据库悲观锁与乐观锁

数据库锁还有一个经常被忽略的问题:锁不是越小越好,也不是越多越安全。

锁粒度越细,并发能力通常越高,但锁管理成本也更高;锁范围越大,实现可能更简单,但其他事务受到的影响也更大。真正应该优化的是“事务中必须互斥的范围”,而不是机械追求某一种锁。

分布式锁解决多个服务实例的唯一执行权

当应用部署成多个实例以后,问题再次发生变化。

假设订单服务运行了 4 个实例:

text
order-service-1
order-service-2
order-service-3
order-service-4

预期结果:

text
4 个彼此独立的服务实例;每个实例拥有自己的 JVM 内存与本地锁状态。

这时每个实例都有自己的 JVM 锁,每台机器也可能有自己的文件锁。它们都不能让另外三台机器停下来。

分布式锁的核心,是让所有竞争者都去同一个协调系统争夺一份“唯一执行权”。这个协调系统可以是 Redis、etcd、ZooKeeper,或者在某些场景下直接使用数据库。

一个可靠的分布式锁至少要解决四件事:

  • 互斥:同一时刻只有一个持有者;
  • 所有权:释放时必须确认锁确实属于自己;
  • 超时:持有者宕机后不能永久占锁;
  • 故障恢复:网络抖动、进程暂停、超时后继续执行都可能导致旧持有者和新持有者同时认为自己有资格操作。

以 Redis 为例,最基础的获取动作通常强调“仅不存在时设置”和“附带过期时间”。下面是命令示例:

bash
redis-cli SET lock:order:1001 worker-a NX PX 30000

预期输出:

text
OK

如果锁已经存在,则返回空结果,表示本次获取失败。

但真正危险的地方在释放锁。不能简单执行:

text
DEL lock:order:1001

上面的内容是反例命令,用于说明为什么不能无条件释放分布式锁,不应在生产代码中直接使用。

因为锁可能已经过期,并被另一个实例重新获得。旧实例此时再无条件删除,就会把新持有者的锁删掉。

因此释放必须带所有权校验。下面是 Redis Lua 片段示例,依赖调用方把锁 key 和自己的 token 传入:

lua
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
end

return 0

预期结果:

text
token 匹配:返回 1,删除自己的锁
token 不匹配或锁不存在:返回 0,不删除其他持有者的锁

分布式锁获取与释放生命周期

实际 Java 项目中,如果已经决定使用 Redis 做分布式协调,通常更适合直接使用 Redisson 这类成熟实现,而不是自己拼接获取、续期、释放和重试逻辑。

公平、可重入、阻塞、自旋这些词到底在说什么

除了“线程锁、文件锁、数据库锁、分布式锁”这种按作用范围划分的体系,还有一组经常出现在锁实现细节中的语义标签。它们不能混为一种分类。

互斥与共享

互斥锁要求同一时刻只有一个持有者。共享锁允许多个兼容持有者同时存在。

最典型的是读写锁:

  • 读锁与读锁可以共存;
  • 读锁与写锁冲突;
  • 写锁与写锁冲突。

可重入与不可重入

可重入表示同一个执行者已经持有锁时,可以再次进入同一把锁保护的代码,而不会把自己阻塞住。

Java 中的 synchronized 和 ReentrantLock 都支持可重入。如果锁不可重入,那么一个已经持锁的方法再次调用另一个需要同一把锁的方法,就可能把自己卡住。

公平与非公平

公平锁更接近排队:先等待的人优先获得机会。

非公平锁允许新来的线程在锁刚释放时直接竞争。这样可能让某些等待者多等一会儿,但减少线程切换和队列调度后,吞吐量往往更高。

因此“公平”不是“更正确”,它只是对等待顺序作出不同取舍。

阻塞与自旋

阻塞等待意味着线程获取不到锁时会被挂起,等待以后再被调度。

自旋则是不立即睡眠,而是短时间持续尝试。如果临界区极短,自旋可以省掉线程挂起和唤醒的开销;如果锁持有时间很长,自旋只是在白白消耗 CPU。

悲观与乐观

悲观锁假设冲突概率高,所以先占有资源。

乐观锁假设冲突没那么频繁,因此允许大家先执行,在提交时再检测有没有被别人修改。

这两个词描述的是冲突策略,不能直接推出“底层一定有没有锁”。例如数据库 version 乐观锁最终执行 UPDATE 时,数据库内部依旧可能使用自己的并发控制与锁机制。

工程选型先判断竞争边界,再决定锁实现

真正做系统设计时,不需要从几十种锁名里“挑一个最厉害的”。可以按照一条固定路径判断。

锁机制工程选型流程

可以把常见场景压缩成这张表:

场景 优先考虑 关键边界
同一 JVM 内多个线程修改共享状态 synchronized / ReentrantLock 只能约束当前 JVM
多读少写 ReadWriteLock 写操作仍然需要独占
控制同时执行数量 Semaphore 解决并发配额,不是唯一执行
同一台机器多个进程 flock / fcntl 不能跨服务器
数据库高冲突修改 SELECT ... FOR UPDATE 必须结合事务、索引和隔离级别
数据库低冲突更新 version 乐观锁 冲突后要能检测并重试
多实例争夺唯一执行权 Redisson / etcd / ZooKeeper 必须考虑 TTL、所有权和故障恢复

锁错了比没锁更隐蔽

很多线上问题不是开发者“忘了加锁”,而是锁虽然存在,却覆盖了错误的范围。

第一种错误是锁太小。只锁了写操作,却把依赖同一份旧状态的读取放在锁外面。看起来每次写都安全,整个“读—判断—写”流程却仍然存在竞态条件。

第二种错误是锁太大。把网络请求、慢 SQL、大文件 IO 全部放进临界区。这样即使逻辑绝对正确,也可能因为锁持有时间过长,把所有并发请求排成单线程。

第三种错误是锁的范围不匹配。例如多实例服务里使用 JVM 锁,代码在单机测试环境完全正常,上线扩容到 4 个实例后立刻出现重复任务。

第四种错误是忘记失败模型。单机锁更多关注线程和进程何时释放;分布式锁还要考虑网络分区、进程暂停、TTL 到期、旧持有者继续执行等问题。

第五种错误是把锁当成幂等。锁只能限制某一段时间内的并发进入,但不能保证操作永远只发生一次。请求重试、消息重复投递、进程崩溃后恢复,都可能再次触发同一业务操作。

另一个必须认识的问题是死锁。

经典死锁通常满足类似条件:线程 A 持有锁 1 等锁 2,线程 B 持有锁 2 等锁 1。两边都不释放,就形成永久等待。

工程里更有效的办法通常不是等死锁出现后再排查,而是从设计上减少条件:

  • 固定多把锁的获取顺序;
  • 缩小临界区;
  • 避免持锁期间调用不可控的外部逻辑;
  • 必要时使用超时获取;
  • 监控长时间持锁与线程阻塞。

最终可以把锁的选型归结为四个连续问题:

  1. 竞争者在哪里? 同线程空间、同一台机器、同一个数据库,还是跨节点?
  2. 竞争资源是什么? 内存状态、本地文件、数据库记录,还是一段跨服务业务动作?
  3. 冲突发生时怎么处理? 等待、失败、重试,还是允许多个读者共享?
  4. 持锁失败怎么办? 超时、进程崩溃、网络异常、重复执行时,系统是否还能恢复?

如果这四个问题回答清楚,锁的名字反而是最后一步。

锁的目标从来不是“让系统绝对串行”,而是只在真正有冲突的最小范围内建立秩序。JVM 内用线程锁,同机进程用文件锁,事务内的数据竞争交给数据库,多节点唯一执行权再引入分布式锁。与此同时,还要把公平、可重入、悲观、乐观、自旋这些词放回它们各自的语义维度。这样面对新的并发问题时,才不是继续背锁名,而是能判断为什么需要锁、锁应该放在哪一层、以及哪种锁刚好够用。

目录与阅读设置

记录一个想法

一文搞懂锁:线程锁、文件锁、数据库锁与分布式锁

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通