mobile wallpaper 1mobile wallpaper 2mobile wallpaper 3mobile wallpaper 4
2857 words
7 minutes
Java 锁专题:从 synchronized 到分布式锁
2025-03-18
2026-09-28

给库存扣减方法加上 synchronized,是否就不会超卖?换成 Redis 锁,是不是就能解决所有并发问题?

判断一把锁有没有用,需要先确定:谁在竞争、竞争的是哪份资源、所有访问者是否遵守同一个约定。锁的名字不决定正确性,锁的作用范围与业务约束是否匹配才决定。

本文以 Java 21 为基准,依次讨论对象监视器、显式锁、读写锁、数据库锁与分布式租约。数据库示例使用 MySQL 8.4、InnoDB 语义。

1. 锁必须覆盖整个“不能被打断”的操作#

假设同一个内存库存对象要被多个线程访问:

final class LocalStock {
private final Object monitor = new Object();
private int available;
LocalStock(int initial) {
if (initial < 0) throw new IllegalArgumentException();
available = initial;
}
boolean reserve(int quantity) {
if (quantity <= 0) throw new IllegalArgumentException();
synchronized (monitor) {
if (available < quantity) return false;
available -= quantity;
return true;
}
}
int available() {
synchronized (monitor) {
return available;
}
}
}

这里保护的是“检查余额并扣减”的完整临界区。读写都使用同一个 monitor,字段不允许外部直接修改。

以下写法每次创建一把新锁,无法让不同调用互斥:

synchronized (new Object()) {
// 每个调用拿到不同对象,不会彼此协调
}

同样,分别在 getStock() 和 decreaseStock() 内加锁,不能保证调用者把它们组合成“先检查、再扣减”时仍然安全。应把业务所需的原子操作封装成一个方法。

2. synchronized 到底锁住谁#

写法监视器对象
实例 synchronized 方法当前 this
静态 synchronized 方法声明该方法的 Class 对象
synchronized (lock)表达式指向的对象

两个不同的服务对象,各自的实例同步方法不会因为方法同名就互斥。静态同步方法与实例同步方法默认使用不同监视器,也不会自动互斥。

synchronized 支持重入:线程持有监视器时,可以再次进入受同一监视器保护的代码。代码块正常结束或异常退出时,监视器会自动释放。所有参与者遵循同一同步规则时,它还建立相应的可见性关系。

临界区应只包含需要共同保护的工作。把远程 HTTP 调用、等待用户输入或大量日志输出放在锁内,会让其他线程为这些等待排队。也不能只为“缩短锁时间”把相关读写移出去,破坏原本的整体性。

3. 需要限时等待时,用显式锁表达#

ReentrantLock 适合需要限时尝试、可中断获取,或者多个条件队列的场景。基础用法的重点是:只有成功拿到锁,才进入需要 unlock 的区域。

下面摘自实验工程的计数器:

private final ReentrantLock lock = new ReentrantLock();
private int value;
public boolean increment(Duration wait) throws InterruptedException {
if (!lock.tryLock(wait.toNanos(), TimeUnit.NANOSECONDS)) {
return false;
}
try {
value++;
return true;
} finally {
lock.unlock();
}
}

false 表示本次没有在期限内取得锁,调用方可以返回忙碌、重试或走其他明确路径;中断通过 InterruptedException 交给调用方决定。读取 value 的方法也要遵循相同的锁规则。

lockInterruptibly() 可在等待获取锁时响应中断。相比之下,等待进入 synchronized 监视器本身不能通过中断直接取消;但已经进入同步块后调用的 wait() 可以响应中断,不能笼统说“synchronized 里面都不可中断”。

公平锁通常倾向于让等待更久的线程取得锁,但不等同于业务请求严格按到达顺序执行。无参数 tryLock() 即使面对公平锁,也允许在锁空闲时直接尝试获取。ReentrantLock API

如果只需要一个简单的互斥临界区,synchronized 往往更容易写对。选择显式锁应对应具体能力需求,而不是默认认为它性能更好。

4. 条件等待时,等待的是状态变化#

假设一个工作线程需要等待队列非空。正确的协调过程是:

拿锁
检查“队列非空”这个条件
条件不满足 → 释放相应锁并等待
被唤醒后重新拿锁
再次检查条件
条件满足 → 取走任务
释放锁

必须重新检查条件,因为唤醒不代表资源一定仍可用,也可能发生虚假唤醒。多个线程被唤醒时,资源可能已经被别的线程取走。

对象监视器提供 wait / notify / notifyAll;显式锁可以创建 Condition,使用 await / signal 等方法。普通生产者消费者场景优先考虑 BlockingQueue,让成熟的容器负责这些细节。

Thread.sleep() 不会释放已经持有的监视器。拿着锁循环 sleep 等待条件,往往使负责修改条件的另一个线程根本拿不到锁。

5. 读写锁适用于哪些读多写少的场景#

ReentrantReadWriteLock 区分两类访问:读操作可以共享读锁,写操作需要独占写锁。它适合读操作之间确实不会修改共享数据、且并行读能带来收益的情况。

“查询方法”不一定是纯读。例如查询时更新普通 Map 中的访问时间,依旧发生了写操作;不能只看方法名就放进读锁区域。

也不要在持有读锁时直接尝试升级为写锁:

读锁内发现缓存缺失
仍持有读锁,开始等待写锁
写锁又需要等待读锁释放

通常应释放读锁,再申请写锁,并重新检查条件;两次加锁之间,别人可能已经填充缓存。写锁可以按 API 规定降级为读锁,但读锁不能直接升级为写锁。ReentrantReadWriteLock API

对于很短的读操作,读写锁的协调成本可能抵消并发收益。如果数据是整体替换的配置,使用 volatile 或 AtomicReference 发布不可变快照,可能更简单,见 CAS 专题。

6. 跨应用实例时,把约束放到共享资源所在处#

Java 锁只协调同一 JVM 中共享该锁对象的线程。多台应用都修改同一个数据库时,可以让数据库负责协调。

当业务必须先读取当前记录,再根据它完成多步判断,可在显式事务中使用锁定读:

START TRANSACTION;
SELECT available
FROM inventory
WHERE sku_id = 1001
FOR UPDATE;
-- 应用检查库存,并在同一连接、同一事务内执行修改
COMMIT;

sku_id 应有合适的唯一索引。锁定范围与访问路径、索引、隔离级别有关,不能把任何一条 FOR UPDATE 都想成“只锁住想要的那一行”。锁定读需要明确的事务边界,提交或回滚后锁才随事务释放。InnoDB 锁定读

事务持锁期间不要等待远程支付或其他慢速服务。若一条条件更新就能表达需求,可以直接写:

UPDATE inventory
SET available = available - :quantity
WHERE sku_id = :skuId
AND available >= :quantity;

应用先校验正数量,再检查影响行数,并把相关订单修改放在同一事务。

数据库乐观锁通常是在 WHERE 中加入版本条件,避免基于旧快照覆盖更新;它不表示执行 UPDATE 时没有数据库锁。悲观与乐观是冲突处理策略,不是“强一致与最终一致”的同义词。

7. 分布式锁首先是一个有期限的使用约定#

Redis 中常见的租约获取形式是:

SET lock:order:1001 <本次持有者的唯一标识> NX PX 10000

它表达“键不存在时建立一个 10 秒租约”。释放时必须核对持有者,比较和删除还必须是同一个原子操作,例如使用 Lua:

if redis.call('GET', KEYS[1]) == ARGV[1] then
return redis.call('DEL', KEYS[1])
end
return 0

这能避免一个过期持有者直接删除后来者的锁。先 GET 判断、再单独 DEL,两个命令之间仍会发生交错。

然而,正确释放还不足以保护业务写入:

A 取得 10 秒租约,开始执行
A 因暂停或网络问题停顿超过 10 秒
租约到期,B 取得新租约
A 恢复,继续向业务资源写入

A 并不会因为 Redis 键过期而自动停止。续约能降低正常任务过期的概率,也无法消除长暂停、网络隔离或失去租约后的旧任务写入风险。Redis 分布式锁文档

对于需要拒绝旧持有者写入的资源,可设计 fencing token:每次授予租约获得递增编号,业务资源在执行实际写入时原子地检查并记录编号,拒绝比已接受编号更旧的写入。用于释放锁的随机唯一标识只证明身份,不具备这种先后顺序。

这还要求授予编号的机制、故障恢复与资源端检查都满足对应保证;只在 Java 中比较一下数字,再发送无条件更新并不够。订单幂等、库存余额等能够由数据库直接表达的规则,仍应保留唯一键、条件更新和事务作为最终约束。

8. 避免死锁,要统一资源获取顺序#

两个线程各拿一把锁,再等对方的锁,就形成循环等待:

线程 A:持有账户 1,等待账户 2
线程 B:持有账户 2,等待账户 1

涉及多个账户的转账,可以按稳定、唯一的账户 ID 排序,始终先锁较小 ID,再锁较大 ID。所有相关入口都要采用同一个规则;同账户操作应单独处理,ID 必须能形成明确的全序。

减少同时持锁数量、缩短临界区,也能降低冲突。限时 tryLock 可以让等待退出,但超时后不加区分地马上重试,仍可能造成活锁或持续竞争。

数据库事务也可能死锁。需要统一更新顺序,并对可重试的事务设置有界重试;重试整个业务动作时,还要保证不会重复调用外部副作用。

9. 发现“卡住”后,先看等待链#

Java 21 可以使用下面的命令查看线程信息,其中 <pid> 替换为目标 Java 进程号:

jcmd <pid> Thread.print -l

使用与目标环境匹配的诊断工具和进程访问权限。具体命令选项见 jcmd 文档。

拿到线程栈后,沿着问题追踪:

  1. 哪些线程在等待同一个对象或同步器?
  2. 持有者正在计算、访问数据库,还是等待另一个锁?
  3. 多份间隔采集的线程栈是否长期停在同一位置?
  4. 有没有形成循环依赖?

BLOCKED 常对应监视器竞争;显式锁的等待可能表现为 WAITING 或 TIMED_WAITING。还应结合 CPU、连接池等待和线程池队列判断,不能把所有请求缓慢都归因于锁。

10. 选择之前,先写清保护范围#

要保护的内容可选机制
单 JVM 的短临界区synchronized
限时或可中断的互斥ReentrantLock
较长、纯读且读多的访问读写锁
数据库中的业务约束条件更新、唯一键、事务
跨进程协调执行资格分布式租约及资源端约束

Java 并发实验工程基于 JDK 21,可通过 mvn test 运行 12 项实验,其中包含同一监视器保护递增、显式锁保护计数,以及 CAS 库存对照。所有等待都设置了上限,未使用故意永久挂起的死锁演示。

这些测试验证本地线程行为;本文的数据库锁与分布式租约说明不包含真实 MySQL、Redis 故障联调。它们对应的业务验收场景,可以结合超卖、幂等与一致性继续设计。

Share

If this article helped you, please share it with others!

Java 锁专题:从 synchronized 到分布式锁
https://mizuki.mysqil.com/posts/java-locks/
Author
梦幻晨风
Published at
2025-03-18
License
CC BY-NC-SA 4.0

Some information may be outdated

Table of Contents