跳到主要内容
约 8 分钟3 张卡

ReentrantLock

ReentrantLock 是一把通过方法调用加锁、解锁的可重入互斥锁。它和 synchronized 一样保证互斥和可见性,区别在于把锁的控制权交给了代码:可以限时等锁、等锁时响应中断、选择公平策略,还能在一把锁上挂多个条件队列。这些能力的代价是释放也要由代码负责。开发者要让每次获取都配对释放,按需要选择获取方式和公平策略,并用 Condition 写出不丢通知、不超出预算的等待循环。

1. 面试核心​

先记住这几条,再读正文
  • ReentrantLock 在提供互斥和可见性的同时,支持可中断获取、超时获取和多个条件队列。
  • 线程每次成功获取 ReentrantLock,都要在对应的 finally 中调用一次 unlock()。
  • 公平锁优先让等待最久的线程获取锁,持续竞争时吞吐通常更低;无超时 tryLock() 仍允许插队。卡 · 可中断获取与超时获取
  • Condition.await() 会完全释放关联锁,返回前重新获取并恢复持有次数,线程随后要用 while 重查条件。卡 · 条件重查与通知时机
  • 带时限的条件等待每轮都使用剩余预算,否则反复唤醒会让总等待时间超出原定期限。卡 · 条件等待的剩余预算

2. 加锁与释放​

显式锁不会因为方法退出而自动释放,所以正常返回和抛出异常两条路径都要经过 unlock()。标准写法是在 try 之前获取锁,在 finally 中释放:

private final ReentrantLock lock = new ReentrantLock();

void update() {
lock.lock();
try {
updateState();
} finally {
lock.unlock();
}
}

lock() 放在 try 外面,是为了保证进入 try 时锁一定已经拿到,finally 释放的就是当前线程持有的锁。如果把获取写进 try,换成可中断获取后,等锁时被中断会直接跳到 finally,去释放一把根本没拿到的锁,unlock() 会抛出 IllegalMonitorStateException,把原来的中断异常盖掉。

重入是指持有锁的线程可以再次获取同一把锁。锁内部记录持有次数,每次获取加一,每次 unlock() 减一,降到零时其他线程才能取得锁。所以获取了几次,就要释放几次;少释放一次,锁会一直被这个线程占着。

3. 可中断获取与超时获取​

ReentrantLock 提供四种获取方式,区别在于等不到锁时怎么办:

  • lock() 一直等到获取成功。等待期间被中断不会退出,只保留中断状态。
  • lockInterruptibly() 等待时响应中断,抛出 InterruptedException,让调用方可以取消等锁。
  • tryLock() 立即返回是否获取成功,不等待,适合只尝试一次的操作。
  • tryLock(timeout, unit) 最多等待给定时间,等待期间也响应中断,适合有截止时间的请求。

请求有截止时间时,等锁的时间也要计入预算。带超时的 tryLock 能限制等待,超时后让调用方拒绝请求或走降级逻辑:

if (lock.tryLock(200, TimeUnit.MILLISECONDS)) {
try {
updateState();
} finally {
lock.unlock();
}
} else {
rejectBusyRequest();
}

示例最多等 200 毫秒:期限内拿到锁就更新状态,超时返回 false,调用 rejectBusyRequest() 拒绝请求。这个方法会抛出 InterruptedException,所在方法需要处理或声明它。

后三种方式都能让线程放弃等锁,所以除了避免无限等待,也能用来跳出多个线程互相等锁的局面:拿不到第二把锁就放弃,释放已经拿到的第一把,稍后重试。放弃时一定要释放此前取得的资源,否则僵局还在。

4. 公平锁与非公平锁​

公平策略决定锁空闲的那一刻,排队已久的线程和刚好到来的线程谁先拿到锁。new ReentrantLock(true) 创建公平锁,优先让等待最久的线程获取;默认构造的是非公平锁,允许新到的线程插队。两种模式下,当前持有者重入都会直接成功。

非公平锁吞吐通常更高,原因在锁交接的那段空档。排队的线程处于阻塞状态,锁释放后要先被唤醒,再等操作系统把它调度到 CPU 上,才能真正去拿锁。非公平锁允许正在运行的线程直接拿走刚释放的锁,省掉了这段空档;公平锁必须把机会留给排队者,锁在交接期间就空着。所以持续竞争时,公平锁吞吐通常更低,但各线程的等待时间更均匀,不容易出现某个线程长期抢不到锁。

有一个例外:无超时的 tryLock() 不遵守公平策略,只要锁空闲就能成功,即使有线程在排队。需要按公平顺序立即尝试时,用 tryLock(0, TimeUnit.SECONDS) 这类零超时写法,它还会响应中断。

公平性只约束获取锁的顺序,线程什么时候被调度运行仍由操作系统决定。业务确实需要限制长期等待时,再启用公平锁,并同时测量吞吐量和等待时间的分布。

5. Condition 等待​

Condition 是与某把锁关联的条件变量,让线程在持锁时等待某个业务条件成立,通过 lock.newCondition() 创建。以队列为例,消费者发现队列为空,就在 notEmpty 上等待,同时释放锁,生产者才有机会拿锁加入数据:

private final Condition notEmpty = lock.newCondition();

Item take() throws InterruptedException {
lock.lockInterruptibly();
try {
while (queue.isEmpty()) {
notEmpty.await();
}
return queue.removeFirst();
} finally {
lock.unlock();
}
}

take() 先持锁检查队列,为空时调用 await()。await() 把释放锁和进入等待作为一个整体完成,生产者只能在消费者已经进入等待之后拿到锁,它发出的通知就不会落在「检查完」和「开始等」之间而丢失。await() 返回前,消费者会重新获取锁,并恢复调用前的持有次数,即使之前重入了多次也一样。

恢复持锁后,while 会再检查一次队列,原因有两个。一是虚假唤醒:线程可能在没有收到通知的情况下从 await() 返回。二是别的消费者可能先拿到锁,把数据取走了。只有确认队列非空,才执行 removeFirst()。第 7 节用两个消费者的例子具体推演。

await() 只释放与这个 Condition 关联的锁,线程持有的其他锁不会释放。如果生产者也需要这些锁才能加入数据,双方就会互相等待。所以设计等待协议时,还要检查等待者手里还握着哪些锁。

6. signal 与 signalAll​

生产者改变共享状态后,要通知在这个条件上等待的线程。更新和通知都在同一把锁内完成:

lock.lock();
try {
queue.addLast(item);
notEmpty.signal();
} finally {
lock.unlock();
}

signal() 不会让消费者立刻运行。收到通知的消费者转去排队等锁,此时生产者仍然持有锁,直到执行 unlock()。消费者要等重新拿到锁,才能从 await() 返回,而那时它一定能看到 addLast 加入的数据。

signal() 唤醒一个等待者,signalAll() 唤醒全部等待者。能确定唤醒一个就够、并且任何一个被唤醒的线程都能处理这次变化时,用 signal()。多个等待者在等不同的条件,或者难以判断该唤醒谁时,用 signalAll(),以免唤醒了一个处理不了的线程,真正该醒的却还在等;被唤醒的线程拿到锁后各自重查条件。

另一个办法是为不同条件创建不同的 Condition。有界队列里,生产者等待「队列未满」,消费者等待「队列非空」,两个条件各用一个 Condition,各自只通知对应的一方,可以减少无关的唤醒。

7. 条件重查与通知时机​

线程从 await() 返回时,条件不一定成立,因为从收到通知到重新拿到锁之间,状态可能又变了。用两个消费者推演一遍:

  1. 两个消费者都发现队列为空,于是进入等待。
  2. 生产者加入一条数据,并通知两个消费者。
  3. 第一个消费者取得锁,取走唯一的数据。
  4. 第二个消费者取得锁时,队列已经再次变空,需要继续等待。

如果用 if 只在等待前检查一次,第二个消费者醒来后会直接对空队列执行 removeFirst()。while 在每次重新持锁后都判断一遍,条件不成立就继续等,虚假唤醒也一并处理了。

8. 条件等待的剩余预算​

带时限的等待,条件迟迟不满足、线程被反复唤醒时,所有轮次应该共用一份预算。awaitNanos 返回估算的剩余纳秒数,下一轮就用这个值继续等:

long remaining = timeoutNanos;
while (queue.isEmpty()) {
if (remaining <= 0L) {
return false;
}
remaining = notEmpty.awaitNanos(remaining);
}
return true;

这段代码在持锁的 try 内执行,外层由 finally 解锁。remaining 每轮都会变小,降到零或以下就返回 false。如果每轮都传入原始的 timeoutNanos,每次唤醒都会让计时重新开始:比如预算 1 秒,每 0.9 秒来一次条件仍不满足的唤醒,线程就可能一直等下去。

如果请求的期限还要覆盖等锁的时间,就在调用入口算出统一的截止时间。之后每次加锁或等待前,用截止时间减去当前时间,得到这一步的剩余预算。

9. 常见问题​

9.1 ReentrantLock 一定比 synchronized 快吗?​

不一定。两者的快慢取决于 JVM 实现、竞争强度和临界区耗时,现代 JVM 对两者的常见路径都做了优化。只需要互斥和可见性时,优先用语义更简单、不会忘记释放的 synchronized。需要超时、可中断获取、公平策略或多个条件队列时,再用 ReentrantLock;性能差异用基准测试判断。

9.2 Condition 可以脱离关联锁使用吗?​

10. 面试题卡片​

11. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明