Java并发编程22-Lock接口

02、Java并发编程:Lock接口

本文是 Java 并发编程系列的第二篇。上一篇我们梳理了线程与共享变量的基础问题,这一篇聚焦 JUC 包下最核心的同步工具------Lock 接口。文章会从线上真实事故的痛点场景切入,依次讲清楚 Lock 是什么、为什么需要它、它是怎么演进过来的、API 怎么用、底层 AQS 如何工作、企业项目里如何落地,并在最后给出与 synchronized、ReentrantReadWriteLock、StampedLock 的横向对比,以及面试官高频追问的问题。读完之后,小白也能直接在业务代码中正确使用显式锁。

文章目录

  • 02、Java并发编程:Lock接口
    • 一、痛点场景:线上库存超卖与锁泄漏事故
      • [1.1 背景还原(STAR 之 S,Situation)](#1.1 背景还原(STAR 之 S,Situation))
      • [1.2 任务与问题(STAR 之 T,Task)](#1.2 任务与问题(STAR 之 T,Task))
      • [1.3 三个典型痛点拆解](#1.3 三个典型痛点拆解)
      • [1.4 痛点解决方案总览](#1.4 痛点解决方案总览)
    • [二、Lock 接口是什么(三维度解析)](#二、Lock 接口是什么(三维度解析))
      • [2.1 专业解释](#2.1 专业解释)
      • [2.2 大白话](#2.2 大白话)
      • [2.3 生活案例](#2.3 生活案例)
      • [2.4 Lock 接口体系结构](#2.4 Lock 接口体系结构)
    • [三、为什么需要 Lock:synchronized 的短板](#三、为什么需要 Lock:synchronized 的短板)
      • [3.1 synchronized 回顾](#3.1 synchronized 回顾)
      • [3.2 Lock 补齐的四类能力](#3.2 Lock 补齐的四类能力)
      • [3.3 大白话总结](#3.3 大白话总结)
    • [四、演进历史:从内置监视器到 JUC 显式锁](#四、演进历史:从内置监视器到 JUC 显式锁)
      • [4.1 JDK 1.0 到 1.4:内置锁一枝独秀](#4.1 JDK 1.0 到 1.4:内置锁一枝独秀)
      • [4.2 JDK 1.5:JUC 与显式锁登场](#4.2 JDK 1.5:JUC 与显式锁登场)
      • [4.3 JDK 1.6:内置锁反向优化](#4.3 JDK 1.6:内置锁反向优化)
      • [4.4 JDK 1.8:StampedLock 补齐乐观读](#4.4 JDK 1.8:StampedLock 补齐乐观读)
      • [4.5 现状与注意事项](#4.5 现状与注意事项)
    • [五、Lock 核心 API 详解与代码实操](#五、Lock 核心 API 详解与代码实操)
      • [5.1 标准加锁模板(Java 实现)](#5.1 标准加锁模板(Java 实现))
      • [5.2 非阻塞尝试获取:tryLock()](#5.2 非阻塞尝试获取:tryLock())
      • [5.3 限时获取:tryLock(long, TimeUnit)](#5.3 限时获取:tryLock(long, TimeUnit))
      • [5.4 可中断获取:lockInterruptibly()](#5.4 可中断获取:lockInterruptibly())
      • [5.5 编码契约:三条不可违反的规则](#5.5 编码契约:三条不可违反的规则)
    • [六、底层原理:AQS 与 CLH 等待队列](#六、底层原理:AQS 与 CLH 等待队列)
      • [6.1 AQS 是什么](#6.1 AQS 是什么)
      • [6.2 获取锁的完整流程](#6.2 获取锁的完整流程)
      • [6.3 可重入语义](#6.3 可重入语义)
      • [6.4 公平锁与非公平锁](#6.4 公平锁与非公平锁)
    • [七、企业项目实战(STAR 完整案例)](#七、企业项目实战(STAR 完整案例))
      • [7.1 场景一:电商库存扣减](#7.1 场景一:电商库存扣减)
      • [7.2 场景二:有界缓冲区生产者消费者(Condition 双条件队列)](#7.2 场景二:有界缓冲区生产者消费者(Condition 双条件队列))
      • [7.3 场景三:读多写少的配置中心(读写锁)](#7.3 场景三:读多写少的配置中心(读写锁))
      • [7.4 Spring 工程中的锁配置示例](#7.4 Spring 工程中的锁配置示例)
      • [7.5 结果与收益(R)](#7.5 结果与收益(R))
    • 八、竞品横向对比:四种锁的优劣势
      • [8.1 选型建议](#8.1 选型建议)
    • 九、常用业务场景清单
    • 十、面试官高频面试题(附答题要点)
      • [10.1 既然有了 synchronized,为什么还需要 Lock?](#10.1 既然有了 synchronized,为什么还需要 Lock?)
      • [10.2 ReentrantLock 的底层实现是什么?](#10.2 ReentrantLock 的底层实现是什么?)
      • [10.3 ReentrantLock 是公平锁还是非公平锁?默认是哪种?](#10.3 ReentrantLock 是公平锁还是非公平锁?默认是哪种?)
      • [10.4 为什么 lock() 要放在 try 块外面,unlock() 放在 finally 里面?](#10.4 为什么 lock() 要放在 try 块外面,unlock() 放在 finally 里面?)
      • [10.5 tryLock()、tryLock(time, unit)、lock()、lockInterruptibly() 有什么区别?](#10.5 tryLock()、tryLock(time, unit)、lock()、lockInterruptibly() 有什么区别?)
      • [10.6 Condition 的 await/signal 与 Object 的 wait/notify 有什么区别?](#10.6 Condition 的 await/signal 与 Object 的 wait/notify 有什么区别?)
      • [10.7 等待为什么必须用 while 循环而不是 if?](#10.7 等待为什么必须用 while 循环而不是 if?)
      • [10.8 ReentrantReadWriteLock 和 StampedLock 的区别?](#10.8 ReentrantReadWriteLock 和 StampedLock 的区别?)
      • [10.9 ReentrantLock 会不会死锁?如何避免?](#10.9 ReentrantLock 会不会死锁?如何避免?)
      • [10.10 synchronized 和 ReentrantLock 在虚拟线程下有什么差异?](#10.10 synchronized 和 ReentrantLock 在虚拟线程下有什么差异?)
    • 十一、避坑清单与最佳实践
    • 十二、总结

一、痛点场景:线上库存超卖与锁泄漏事故

1.1 背景还原(STAR 之 S,Situation)

某电商大促期间,库存服务面向秒杀接口。后端使用一个 InventoryService 维护商品剩余库存,多个下单线程并发进入扣减逻辑。最初开发同学使用 synchronized 修饰扣减方法,本以为线程安全没有问题。

大促当天监控告警如下:

  • 库存表中部分商品剩余数量变成负数,出现超卖;
  • 个别请求长时间阻塞,线程堆栈全部停在等待同一把内置锁上,无法被中断;
  • 一次灰度发布中,重构后的代码在扣减库存时抛出运行时异常,获取锁的线程崩溃退出后,其他线程全部永久阻塞,服务假死;
  • 运营提出需求:高峰期只允许等待 200 毫秒,拿不到锁就直接返回"售罄",synchronized 没有提供任何超时入口。

1.2 任务与问题(STAR 之 T,Task)

作为接手该服务的开发,需要在不引入分布式锁的前提下,用单机 JVM 内的同步机制解决以下问题:

  1. 保证库存扣减的原子性,杜绝超卖;
  2. 锁等待必须可以被中断,便于优雅停机与线程池取消任务;
  3. 获取锁必须支持超时,避免请求无限阻塞拖垮服务;
  4. 锁必须在异常路径下也能被可靠释放;
  5. 在特定业务下需要区分"队列已满"和"队列已空"两类等待条件,唤醒时只通知对应的等待方。

1.3 三个典型痛点拆解

痛点一:synchronized 的等待过程不可中断、不可超时。 一旦线程排队等待内置监视器锁,外部调用 interrupt() 无法让它中途退出,synchronized 也没有"等 200 秒拿不到就放弃"的 API。线程池关闭、接口熔断时,这些线程会一直卡在入口处。

痛点二:显式锁如果忘记在 finally 中释放,会造成锁泄漏。 与 synchronized 由 JVM 在退出同步块时自动释放不同,Lock 是一把"手动开关的锁"。如果 lock() 之后业务代码抛出异常,而 unlock() 没有放在 finally 中,锁就永远不会释放,其他线程全部永久阻塞。

痛点三:一个对象监视器只能挂一个等待队列。 Object.wait()/notify() 所有等待线程共用同一个等待集合,notify() 随机唤醒一个,无法精确区分"等待不满的生产者"和"等待不空的消费者",容易出现错误唤醒甚至死锁。

1.4 痛点解决方案总览

上述问题恰好都是 java.util.concurrent.locks.Lock 接口及其实现类解决的范围:

  • lockInterruptibly() 提供可中断的锁获取;
  • tryLock(long timeout, TimeUnit unit) 提供限时获取;
  • unlock() 配合 finally 保证异常路径释放;
  • newCondition() 支持多个独立等待条件队列;
  • 实现类 ReentrantLock 还支持公平锁与非公平锁两种策略选择。

二、Lock 接口是什么(三维度解析)

2.1 专业解释

Lock 是 java.util.concurrent.locks 包下定义的一个同步接口,位于 JDK 1.5 引入的 JUC 框架中。它为"互斥锁"抽象出一套显式的加锁与解锁契约:线程在进入临界区之前调用加锁方法获取锁,离开临界区时调用解锁方法释放锁;锁对象在同一时刻最多只被一个线程持有,从而保证临界区代码的互斥执行。

接口的全部方法签名如下:

java 复制代码
public interface Lock {
    // 获取锁,阻塞直到拿到
    void lock();

    // 获取锁,等待过程可被中断
    void lockInterruptibly() throws InterruptedException;

    // 尝试非阻塞获取,拿到返回 true,拿不到返回 false
    boolean tryLock();

    // 限时获取,在指定时间内未拿到返回 false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    // 释放锁
    void unlock();

    // 绑定一个条件等待队列
    Condition newCondition();
}

与 synchronized 基于对象头 Mark Word 和监视器(Monitor)的隐式同步不同,Lock 是普通 Java 对象上的显式 API,加锁与解锁动作由代码显式调用,锁的持有状态、等待队列、唤醒策略都由实现类自行管理。

2.2 大白话

synchronized 像公共厕所门上那种自动锁:你进门,门自动锁上;你出来,门自动弹开,你不需要记得任何开关动作。Lock 则像一把手动挂锁:进门之前你自己把锁挂上,出门之后你自己把锁摘掉。挂锁可以选择"等不及就走"(tryLock)、"别人喊我走我就走"(lockInterruptibly),还能在锁上挂多把不同的等待号码牌(多个 Condition)。代价是你必须记得出门摘锁,忘了摘,后面所有人都进不去。

2.3 生活案例

写字楼电梯口的等候人群可以类比锁的竞争:

  • 一部电梯同一时间只载一组人,这就是互斥;
  • 先到先排、依次进入,是公平锁;
  • 有人看到电梯门正好打开就直接挤进去插队,是非公平锁;
  • 高峰期等待电梯超过 30 秒就改走楼梯,对应 tryLock 超时放弃;
  • 火警铃响起,所有等待者立刻疏散,对应可中断获取;
  • 大堂经理分两条队伍登记:"满员等候"队伍和"空位等候"队伍,对应两个 Condition 条件队列。

2.4 Lock 接口体系结构

JUC 锁体系中与 Lock 直接相关的成员:

  • Lock:顶层互斥锁接口;
  • ReentrantLock:可重入互斥锁,Lock 最常用的实现;
  • ReadWriteLock:读写锁接口,维护一对读锁与写锁;
  • ReentrantReadWriteLock:读写锁的可重入实现;
  • StampedLock:JDK 8 引入的读写锁增强版,支持乐观读;
  • Condition:与锁绑定的条件等待对象,替代 Object 的等待唤醒机制。

三、为什么需要 Lock:synchronized 的短板

3.1 synchronized 回顾

synchronized 可以修饰实例方法、静态方法或代码块,底层依赖对象监视器。它具备可重入语义:持有锁的线程再次进入同锁同步块不会被自己阻塞。JDK 6 之后,内置锁经过偏向锁、轻量级锁、自旋、锁消除、锁粗化等一系列优化,在低竞争场景下性能已经与显式锁接近。

3.2 Lock 补齐的四类能力

能力维度 synchronized Lock 接口
获取锁是否可中断 等待中不响应中断 lockInterruptibly() 响应中断
获取锁是否可超时 不支持 tryLock(time, unit) 支持限时
非阻塞尝试获取 不支持,拿不到就进入阻塞 tryLock() 立即返回布尔值
等待条件队列 每个对象只有一个等待集合 一个锁可绑定多个 Condition
公平性选择 非公平 构造时可选公平或非公平
锁释放方式 JVM 退出同步块自动释放 代码显式调用 unlock(),须配合 finally

3.3 大白话总结

synchronized 是省心但不够灵活的自动挡:日常通勤足够用,但你不能手动干预换挡。Lock 是手动挡:操作步骤更多、对开发者要求更高,但可中断、可超时、多条件等待、公平性可选这些精细控制,自动挡给不了。二者不是替代关系,而是按场景选择。

四、演进历史:从内置监视器到 JUC 显式锁

理解 Lock 为什么长今天这个样子,需要回顾 Java 同步机制的四个阶段。

4.1 JDK 1.0 到 1.4:内置锁一枝独秀

早期 Java 唯一的线程同步手段就是 synchronized,配套 Object 的 wait/notify/notifyAll。所有跨线程协作都围绕对象监视器展开。这一时期内置锁性能较差:竞争时线程进入阻塞依赖操作系统内核态线程挂起与唤醒,上下文切换成本高;且不支持中断等待、不支持超时,工程上容易出现长时间阻塞。

4.2 JDK 1.5:JUC 与显式锁登场

Doug Lea 主导的 java.util.concurrent 包随 JDK 1.5 发布,Lock、ReadWriteLock、Condition 接口,以及 ReentrantLock、ReentrantReadWriteLock、AbstractQueuedSynchronizer(AQS)第一次进入标准库。显式锁基于 volatile 状态变量、CAS 自旋和 FIFO 等待队列实现,在竞争场景下显著降低了内核态切换开销,同时补齐了可中断、超时、多条件等待等能力。

4.3 JDK 1.6:内置锁反向优化

为了缩小与显式锁的差距,JDK 1.6 对 synchronized 做了大量优化:引入偏向锁、轻量级锁、自适应自旋、锁消除、锁粗化,并改进对象头 Mark Word 的记录方式。无竞争或低竞争时,内置锁的开销大幅下降;锁升级路径从无锁到偏向锁、轻量级锁、重量级锁逐级进行。这也是今天很多场景下 synchronized 依然是首选的历史原因。

4.4 JDK 1.8:StampedLock 补齐乐观读

JDK 8 引入 StampedLock,在读写锁基础上增加乐观读(乐观读不加读锁,读完后校验票据是否被写操作修改),进一步提升读多写少场景的并发度。它不可重入,也不支持 Condition,属于面向特定场景的特化工具。

4.5 现状与注意事项

当前 JDK 中 synchronized 与 Lock 并存。低竞争、简单互斥的代码优先使用 synchronized;需要可中断、超时、多条件等待或公平性控制时使用 ReentrantLock。另外在虚拟线程(Project Loom)场景下,synchronized 临界区内的阻塞会导致载体线程钉住(pinning),而 ReentrantLock 在后续版本中已缓解该问题;编写面向虚拟线程的代码时需要把这一差异纳入评估。

五、Lock 核心 API 详解与代码实操

5.1 标准加锁模板(Java 实现)

ReentrantLock 是 Lock 接口最基础、最常用的实现。下面是生产代码中必须遵守的标准模板:lock() 放在 try 块之外,unlock() 放在 finally 块的第一行。

java 复制代码
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {

    private final Lock lock = new ReentrantLock();
    private long count = 0;

    public void increment() {
        lock.lock(); // 加锁必须在 try 之外,避免未拿到锁却在 finally 中误释放
        try {
            count++; // 临界区代码
        } finally {
            lock.unlock(); // 解锁必须在 finally,保证异常路径也释放锁
        }
    }

    public long getCount() {
        return count;
    }
}

对应的 Python 对照实现。Python 标准库 threading.Lock 同样是显式互斥锁,语义上与 ReentrantLock 的不可重入版本接近;Python 的可重入锁为 threading.RLock。

python 复制代码
import threading


class Counter:
    def __init__(self):
        self._lock = threading.Lock()
        self._count = 0

    def increment(self):
        # acquire 对应 lock(),release 对应 unlock()
        self._lock.acquire()
        try:
            self._count += 1
        finally:
            self._lock.release()

    def get_count(self):
        return self._count

5.2 非阻塞尝试获取:tryLock()

tryLock() 不等待:拿到锁立即返回 true,拿不到立即返回 false。适合"抢不到就做别的事"的场景,例如定时任务抢锁执行。

java 复制代码
import java.util.concurrent.locks.ReentrantLock;

public class TryLockDemo {

    private final ReentrantLock lock = new ReentrantLock();

    public void tryTask() {
        if (lock.tryLock()) {
            try {
                System.out.println("拿到锁,执行业务");
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("未拿到锁,直接跳过或执行降级逻辑");
        }
    }
}

Python 对照实现,acquire(blocking=False) 即非阻塞获取:

python 复制代码
import threading


class TryLockDemo:
    def __init__(self):
        self._lock = threading.Lock()

    def try_task(self):
        if self._lock.acquire(blocking=False):
            try:
                print("拿到锁,执行业务")
            finally:
                self._lock.release()
        else:
            print("未拿到锁,直接跳过或执行降级逻辑")

5.3 限时获取:tryLock(long, TimeUnit)

限时获取是解决"请求无限阻塞"的核心 API。在指定时间内拿到锁返回 true,超时返回 false;等待过程中被中断则抛出 InterruptedException。

java 复制代码
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TimeoutLockDemo {

    private final ReentrantLock lock = new ReentrantLock();

    public boolean deductStock() throws InterruptedException {
        // 最多等待 200 毫秒,拿不到锁就返回 false,由上层降级处理
        if (lock.tryLock(200, TimeUnit.MILLISECONDS)) {
            try {
                // 扣减库存的临界区逻辑
                return true;
            } finally {
                lock.unlock();
            }
        }
        return false;
    }
}

Python 对照实现,acquire(timeout=0.2) 对应限时获取:

python 复制代码
import threading


class TimeoutLockDemo:
    def __init__(self):
        self._lock = threading.Lock()

    def deduct_stock(self):
        # 最多等待 0.2 秒,拿不到锁返回 False
        if self._lock.acquire(timeout=0.2):
            try:
                return True
            finally:
                self._lock.release()
        return False

5.4 可中断获取:lockInterruptibly()

普通 lock() 等待期间不响应中断;lockInterruptibly() 在等待队列中收到中断信号时会立即抛出 InterruptedException,线程可以退出等待、做资源清理后结束。在线程池 shutdownNow()、任务取消等场景中必须使用它。

java 复制代码
import java.util.concurrent.locks.ReentrantLock;

public class InterruptibleLockDemo {

    private final ReentrantLock lock = new ReentrantLock();

    public void task() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            // 临界区逻辑
        } finally {
            lock.unlock();
        }
    }
}

调用方需要妥善处理中断:捕获 InterruptedException 后,通常应通过 Thread.currentThread().interrupt() 恢复中断标记,再向上层传播,避免中断状态被吞掉。

5.5 编码契约:三条不可违反的规则

  1. lock()、lockInterruptibly()、tryLock 返回 true 之后,才必须调用 unlock();未拿到锁时调用 unlock() 会抛出 IllegalMonitorStateException。
  2. unlock() 必须放在 finally 块中,且通常作为 finally 的第一条语句,保证任何异常路径都能释放锁。
  3. 加锁范围尽量小:只保护共享可变状态的临界区,不要把远程调用、数据库事务、耗时 IO 放进锁内,否则会严重降低并发度并增加死锁风险。

六、底层原理:AQS 与 CLH 等待队列

6.1 AQS 是什么

ReentrantLock 等 JUC 同步器的共同底座是 AbstractQueuedSynchronizer(AQS)。它提供三个核心构件:

  • state:一个 volatile int 类型的同步状态。在 ReentrantLock 中,0 表示无锁,大于 0 表示当前线程持有锁的重入次数;
  • CLH 变体的 FIFO 双向队列:存放获取锁失败而被阻塞的等待线程节点;
  • CAS 操作:通过 compareAndSetState 原子地修改状态,避免加锁过程本身的并发问题。

6.2 获取锁的完整流程

  1. 线程尝试用 CAS 修改 state:无锁时把 0 改为 1;
  2. 如果 CAS 成功,记录当前持有锁的线程,获取成功;
  3. 如果当前线程就是已持锁线程(可重入场景),state 加 1;
  4. 如果 CAS 失败,线程被包装成队列节点加入 CLH 队列尾部;
  5. 队列中的节点等待前驱节点唤醒,被唤醒后再次尝试 CAS;
  6. 释放锁时 state 减 1,减到 0 时唤醒队列中后继节点。

6.3 可重入语义

ReentrantLock 的"可重入"体现在:持有锁的线程再次进入同锁临界区时,不需要阻塞,只需把 state 累加;退出时逐层递减,只有最后一次退出把 state 降为 0 才真正释放锁。这与 synchronized 的重入行为一致。

6.4 公平锁与非公平锁

ReentrantLock 构造时可以选择两种策略:

java 复制代码
// 非公平锁(默认)
Lock nonFair = new ReentrantLock();

// 公平锁
Lock fair = new ReentrantLock(true);
  • 非公平锁:新线程到来时先直接 CAS 抢一次锁,抢不到再排队。允许"插队",减少线程挂起与唤醒的开销,吞吐量更高,但队列中的线程可能长时间得不到锁;
  • 公平锁:任何线程获取锁前先检查队列中是否有前驱等待节点,有则排队,严格 FIFO。等待时间可预测,但上下文切换更多,吞吐量略低。

生产环境绝大多数场景使用默认非公平锁;只有业务明确要求等待顺序公平(例如严格按请求顺序分配资源)时才开启公平锁。

七、企业项目实战(STAR 完整案例)

7.1 场景一:电商库存扣减

背景(S) :秒杀接口并发扣减商品库存,库存为共享可变成员变量。

任务(T) :保证扣减原子性,杜绝超卖;拿不到锁限时降级,不允许线程无限阻塞。

行动(A) :使用 ReentrantLock 保护库存读取与扣减的复合操作,tryLock 设置超时,临界区只包含内存状态更新,扣减成功后再落库。

java 复制代码
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class InventoryService {

    private final ReentrantLock lock = new ReentrantLock();
    private int stock;

    public InventoryService(int stock) {
        this.stock = stock;
    }

    public boolean deduct(int quantity) throws InterruptedException {
        if (!lock.tryLock(200, TimeUnit.MILLISECONDS)) {
            // 排队超时,上层返回"售罄"或稍后重试
            return false;
        }
        try {
            if (stock < quantity) {
                return false;
            }
            stock -= quantity;
            // 此处仅演示内存扣减;真实项目在锁内更新库存后,事务与持久化在锁外编排
            return true;
        } finally {
            lock.unlock();
        }
    }

    public int remaining() {
        return stock;
    }
}

Python 对照实现,使用 threading.Lock 与超时获取:

python 复制代码
import threading


class InventoryService:
    def __init__(self, stock: int):
        self._lock = threading.Lock()
        self._stock = stock

    def deduct(self, quantity: int) -> bool:
        if not self._lock.acquire(timeout=0.2):
            return False
        try:
            if self._stock < quantity:
                return False
            self._stock -= quantity
            return True
        finally:
            self._lock.release()

    def remaining(self) -> int:
        return self._stock

7.2 场景二:有界缓冲区生产者消费者(Condition 双条件队列)

背景(S) :订单解析模块中,生产者线程写入解析任务,消费者线程取出执行,缓冲区容量固定为 5。

任务(T) :缓冲区满时生产者等待,缓冲区空时消费者等待;唤醒必须精准,不能让生产者唤醒生产者、消费者唤醒消费者。

行动(A) :一把 ReentrantLock 绑定两个 Condition:notFull 管理生产者等待,notEmpty 管理消费者等待。

java 复制代码
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class BoundedBuffer<T> {

    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public BoundedBuffer(int capacity) {
        this.capacity = capacity;
    }

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            // 必须用 while 而非 if,防止被唤醒后条件已被其他线程改变
            while (queue.size() == capacity) {
                notFull.await(); // 释放锁并进入 notFull 等待队列
            }
            queue.add(item);
            notEmpty.signal(); // 唤醒一个等待"非空"的消费者
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            T item = queue.poll();
            notFull.signal(); // 唤醒一个等待"非满"的生产者
            return item;
        } finally {
            lock.unlock();
        }
    }
}

Python 对照实现,使用 threading.Condition,其 wait/notify 语义与 Condition.await/signal 一一对应:

python 复制代码
import threading
from collections import deque


class BoundedBuffer:
    def __init__(self, capacity: int):
        self._queue = deque(maxlen=capacity)
        self._lock = threading.Condition()

    def put(self, item):
        with self._lock:
            while len(self._queue) == self._queue.maxlen:
                self._lock.wait()
            self._queue.append(item)
            self._lock.notify()

    def take(self):
        with self._lock:
            while not self._queue:
                self._lock.wait()
            item = self._queue.popleft()
            self._lock.notify()
            return item

两个关键细节:等待判断必须用 while 循环而不是 if,因为线程被唤醒后、重新拿到锁之前,条件可能已被其他线程再次改变;signal 只唤醒对应条件队列中的一个等待者,signalAll 唤醒全部。

7.3 场景三:读多写少的配置中心(读写锁)

背景(S) :系统配置注册中心,配置项被大量线程读取,只有管理员偶尔更新。

任务(T) :读读并发、读写互斥、写写互斥,避免一把独占锁把读请求全部串行化。

行动(A) :使用 ReentrantReadWriteLock,读操作获取读锁(共享),写操作获取写锁(独占)。

java 复制代码
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ConfigCenter {

    private final Map<String, String> config = new ConcurrentHashMap<>();
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public String get(String key) {
        rwLock.readLock().lock();
        try {
            return config.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void put(String key, String value) {
        rwLock.writeLock().lock();
        try {
            config.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

7.4 Spring 工程中的锁配置示例

在 Spring 业务服务中,锁对象通常作为 Bean 注入,避免每个工具类各自 new 一把锁。下面是配套的配置写法,先给出 yaml 配置,再给出 Java 配置类。

yaml 复制代码
app:
  lock:
    # fair=false 使用非公平锁;true 为公平锁
    fair: false
    # 获取锁超时时间,毫秒
    acquire-timeout-ms: 200
java 复制代码
import java.util.concurrent.locks.ReentrantLock;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class LockConfig {

    @Value("${app.lock.fair:false}")
    private boolean fair;

    @Bean
    public ReentrantLock businessLock() {
        return new ReentrantLock(fair);
    }
}

使用时通过构造器注入 ReentrantLock,而不是在业务方法内新建,保证同一共享状态对应的是同一把锁。

7.5 结果与收益(R)

上线改造后:库存扣减链路未再出现超卖;排队超时使慢请求在 200 毫秒内降级,线程池水位恢复正常;Condition 双条件队列消除了错误唤醒;配置中心读接口在读写锁下吞吐量显著高于独占锁版本。同时统一的加锁模板纳入代码评审规范,异常路径的锁泄漏问题不再出现。

八、竞品横向对比:四种锁的优劣势

对比维度 synchronized ReentrantLock ReentrantReadWriteLock StampedLock
引入版本 JDK 1.0 JDK 1.5 JDK 1.5 JDK 1.8
锁类型 独占悲观锁 独占可重入锁 读写分离锁(读共享、写独占) 读写锁增强,含乐观读
是否可重入 是 是 读锁写锁均可重入 不可重入
可中断获取 否 是(lockInterruptibly) 读锁写锁均可中断 支持中断获取
超时获取 否 是(tryLock) 是(tryLock) 是(tryConvertToWriteLock 等)
多条件队列 单一等待集合 多个 Condition 多个 Condition 不支持 Condition
公平性可选 仅非公平 可选公平或非公平 可选公平或非公平 仅非公平
乐观读 不支持 不支持 不支持 支持,读完校验票据
语法成本 低,JVM 自动释放 中,须手动 unlock 并配合 finally 中,两把锁分别管理 较高,票据语义需仔细处理
适用场景 简单互斥、低竞争临界区 需要中断、超时、公平性、多条件队列 读多写少的缓存、配置、元数据 读极多写极少、可接受乐观读校验的场景

8.1 选型建议

  • 代码只需要简单互斥、没有特殊控制需求:优先 synchronized;
  • 需要可中断、超时、非阻塞尝试、公平锁或多个等待条件:选 ReentrantLock;
  • 读多写少,且读操作远多于写操作:选 ReentrantReadWriteLock;
  • 读并发压力极大,读临界区很短,能接受乐观读失败后重读:选 StampedLock;
  • 任何情况下都要避免锁嵌套顺序不一致导致的死锁,并尽量缩小锁粒度。

九、常用业务场景清单

  1. 库存与计数器:保护"读取判断再更新"的复合操作,保证扣减原子性;
  2. 任务队列与缓冲区 :生产者消费者模型,用两个 Condition 分离满与空的等待;
  3. 缓存与配置中心:读多写少场景使用读写锁提升读并发;
  4. 单例初始化与共享工具类:保护静态或单例对象中的可变状态;
  5. 串行化外部资源访问:保护非线程安全的第三方客户端、文件句柄、打印任务;
  6. 限时降级 :tryLock 超时后走兜底逻辑,防止请求堆积;
  7. 优雅停机 :lockInterruptibly 让等待锁的任务能响应线程中断,配合线程池关闭;
  8. 公平调度:严格按到达顺序分配资源的任务队列,使用公平锁保证顺序。

十、面试官高频面试题(附答题要点)

10.1 既然有了 synchronized,为什么还需要 Lock?

答题要点:synchronized 等待不可中断、不可超时、只有单一等待队列、无法选择公平性;Lock 提供 lockInterruptibly、限时 tryLock、多个 Condition、公平锁选项,显式释放也带来更灵活的锁控制。二者互补,不是替代。

10.2 ReentrantLock 的底层实现是什么?

答题要点:基于 AQS。核心是 volatile int state 表示同步状态与重入次数,CLH 变体 FIFO 双向队列管理等待线程,CAS 修改状态,持锁线程记录在 AbstractOwnableSynchronizer 中;释放时状态递减,归零后唤醒后继节点。

10.3 ReentrantLock 是公平锁还是非公平锁?默认是哪种?

答题要点:两种都支持,构造参数 fair 控制;默认非公平锁。非公平允许新线程先 CAS 抢锁,吞吐量更高;公平锁严格 FIFO,等待顺序可预测但性能略低。

10.4 为什么 lock() 要放在 try 块外面,unlock() 放在 finally 里面?

答题要点:如果 lock() 在 try 内且加锁失败抛异常,finally 仍会执行 unlock(),此时线程并未持有锁,会抛出 IllegalMonitorStateException。lock() 放 try 外,只有确认拿到锁后才进入 try;unlock() 放 finally 第一行,保证临界区抛出任何异常都能释放锁。

10.5 tryLock()、tryLock(time, unit)、lock()、lockInterruptibly() 有什么区别?

答题要点:lock() 阻塞等待且不响应中断;lockInterruptibly() 阻塞等待但响应中断并抛 InterruptedException;tryLock() 非阻塞立即返回布尔值;tryLock(time, unit) 限时等待,超时返回 false,等待中可被中断。

10.6 Condition 的 await/signal 与 Object 的 wait/notify 有什么区别?

答题要点:一个 Lock 可以创建多个 Condition,每个条件对应独立等待队列,可以精确唤醒某一类等待线程;Object 只有一个等待集合,notify 随机唤醒。await 会释放锁并在被唤醒后重新竞争锁,语义与 wait 对应,但绑定在显式锁之上。

10.7 等待为什么必须用 while 循环而不是 if?

答题要点:线程被唤醒后到重新持有锁之间,条件可能已被其他线程改变(虚假唤醒或多个等待者竞争)。用 while 在重新拿到锁后再次检查条件,不满足则继续等待;用 if 会跳过二次检查,导致条件已不满足仍执行临界区逻辑。

10.8 ReentrantReadWriteLock 和 StampedLock 的区别?

答题要点:读写锁读共享写独占,可重入,支持 Condition;StampedLock 在 JDK 8 引入,支持乐观读(不加读锁,读完校验票据),并发度更高,但不可重入、不支持 Condition,票据转换使用不当容易出错,适合读极多写极少的短临界区。

10.9 ReentrantLock 会不会死锁?如何避免?

答题要点:会。锁嵌套顺序不一致、持锁期间永久阻塞、忘记释放锁都可能导致死锁。避免方式:固定加锁顺序、缩小锁粒度、使用 tryLock 超时放弃、保证 unlock 在 finally、避免持锁时调用外部未知回调。

10.10 synchronized 和 ReentrantLock 在虚拟线程下有什么差异?

答题要点:JDK 早期版本中,synchronized 临界区内阻塞会钉住载体线程;ReentrantLock 已在后续版本中缓解钉住问题。面向虚拟线程的高并发服务需要结合 JDK 版本评估锁内阻塞行为,必要时把阻塞操作移出临界区。

十一、避坑清单与最佳实践

  1. 永远不要把 unlock() 写在普通代码路径,必须放进 finally;
  2. 未成功获取锁时不要调用 unlock(),否则抛出监视器状态异常;
  3. 临界区只保护共享可变状态,远程调用、事务、IO 不要放进锁内;
  4. 多把锁时全局约定加锁顺序,避免交叉持锁;
  5. 优先非公平锁,除非业务明确要求公平顺序;
  6. 使用 Condition 时坚持 while 循环检查条件;
  7. 捕获 InterruptedException 后恢复中断标记,不要吞掉中断状态;
  8. 锁对象声明为 final,避免引用被替换导致不同线程使用不同的锁;
  9. 低竞争简单场景优先 synchronized,不要为了用 Lock 而用 Lock;
  10. 并发问题优先从"是否真的需要共享可变状态"思考,不可变对象与线程局部变量是更彻底的并发方案。

十二、总结

Lock 接口是 JUC 显式锁体系的契约入口:lock、unlock 定义基础互斥,tryLock 提供非阻塞与限时获取,lockInterruptibly 响应中断,newCondition 提供多条件等待。它的主流实现 ReentrantLock 基于 AQS 的 state、CAS 与 FIFO 等待队列实现可重入互斥,并支持公平与非公平两种策略;读写锁与 StampedLock 则面向读多写少场景提供更高的并发度。

工程实践中的判断标准很清晰:简单互斥用 synchronized;需要精细控制(中断、超时、公平、多条件)用 ReentrantLock;读多写少用读写锁或 StampedLock。无论使用哪一种锁,缩小临界区、保证异常路径释放、固定加锁顺序,都是必须守住的底线。


本文为原创文章,如需转载,请联系作者获得授权,并注明出处。

相关推荐
oil欧哟17 分钟前
AI 编程与写作高效工作流:语音输入、反问采访与多话题并行
人工智能
翰墨之道21 分钟前
黄仁勋回归传闻升温:英伟达领导层风波牵动AI产业
人工智能·数据挖掘·回归
天天代码码天天22 分钟前
把闲置电脑变成家庭照片备份站:开源 lw.HomeNAS v1.5.0 发布
人工智能
电科_银尘26 分钟前
【大模型算法与工程 01】机器学习的问题定义:监督、无监督、自监督与强化学习
人工智能·算法·机器学习
文丑颜不良啊31 分钟前
LeetCode3081~3100题目解析
java·leetcode
沉默王二39 分钟前
真狠啊,DeepSeek 开放全家桶 API。
人工智能·agent·deepseek
SimonKing42 分钟前
快讯!local-notes素笺笔记又又又更新了!
java·后端·程序员
Rain的Java大神之路1 小时前
面试官:设计一个自动售货机系统。我:别急着写代码,先问5个问题|状态机+防超卖+断电自愈,一套答法讲透
java·后端·面试
挖掘狂人1 小时前
飞书群聊已读,是怎么实现的?
java·程序员·架构