Java并发编程之Lock锁机制深度解析：从使用到源码实现

news/2025/10/29 8:44:56/文章来源:https://www.cnblogs.com/sun-10387834/p/19171441

1. 锁的基本概念：从现实世界到代码世界

1.1 锁的演进：synchronized → Lock

想象一下健身房储物柜的使用场景：

synchronized：像固定密码锁 - 简单易用但功能有限
Lock接口：像智能电子锁 - 功能丰富且灵活可控

// synchronized - 固定密码锁
public synchronized void oldMethod() {// 自动上锁和解锁// 但无法中断、无法超时、无法尝试获取
}// Lock - 智能电子锁  
public void newMethod() {Lock lock = new ReentrantLock();lock.lock();  // 手动开锁try {// 临界区代码} finally {lock.unlock();  // 手动关锁}
}

1.2 Lock接口的核心优势

特性	synchronized	Lock
中断响应	❌	✅
超时控制	❌	✅
尝试获取	❌	✅
公平性	❌	✅
条件队列	单个	多个

2. AQS：并发世界的交通指挥中心

2.1 AQS的核心设计思想

AQS（AbstractQueuedSynchronizer）就像高速公路收费站系统：

state状态：当前可通行的车道数量
同步队列：等待通行的车辆排队
CAS操作：智能的车辆调度系统

/*** AQS同步状态管理示例*/
public class AQSCoreConcept {// state字段的三种典型用法：// 1. 互斥锁：state = 0(未锁定) 或 1(已锁定)// 2. 重入锁：state = 重入次数  // 3. 读写锁：高16位 = 读锁计数，低16位 = 写锁计数private volatile int state;// 三个核心的state操作方法：protected final int getState() { return state; }protected final void setState(int newState) { state = newState; }protected final boolean compareAndSetState(int expect, int update) {// CAS原子操作，保证线程安全return unsafe.compareAndSwapInt(this, stateOffset, expect, update);}
}

2.2 同步队列：线程的"等候区"

/*** AQS同步队列结构演示*/
public class SyncQueueDemo {/*** 同步队列节点结构（双向链表）：* * head (虚拟节点) ↔ [prev|thread|next|waitStatus] ↔ [prev|thread|next|waitStatus] ↔ tail* * waitStatus状态说明：* - CANCELLED(1)：线程已取消* - SIGNAL(-1)：后继线程需要被唤醒  * - CONDITION(-2)：线程在Condition队列中* - PROPAGATE(-3)：共享模式下传播唤醒*/// 独占模式获取锁的典型流程public void acquireDemo() {Lock lock = new ReentrantLock();// 底层调用AQS的acquire方法lock.lock();  // -> sync.acquire(1);/*** acquire方法执行流程：* 1. tryAcquire()尝试直接获取锁* 2. 失败 → addWaiter()加入同步队列队尾* 3. acquireQueued()在队列中自旋等待* 4. 被前驱节点唤醒后重新尝试获取锁*/}
}

2.3 自定义锁实战：基于AQS实现TwinsLock

/*** TwinsLock - 同一时刻最多允许两个线程访问的共享锁* 设计思路：将AQS的state作为许可证计数器*/
public class TwinsLock implements Lock {private final Sync sync = new Sync(2);private static final class Sync extends AbstractQueuedSynchronizer {Sync(int count) {if (count <= 0) throw new IllegalArgumentException("计数必须大于0");setState(count);  // 初始化许可证数量}/*** 共享模式获取锁* @return 负数：获取失败；0：获取成功但无剩余；正数：获取成功且有剩余*/@Overridepublic int tryAcquireShared(int reduceCount) {for (;;) {  // 自旋避免CAS失败int current = getState();int newCount = current - reduceCount;// 如果新计数<0（无许可证）或CAS设置成功，返回结果if (newCount < 0 || compareAndSetState(current, newCount)) {return newCount;}}}/*** 共享模式释放锁*/@Overridepublic boolean tryReleaseShared(int returnCount) {for (;;) {int current = getState();int newCount = current + returnCount;if (compareAndSetState(current, newCount)) {return true;}}}}@Overridepublic void lock() {sync.acquireShared(1);  // 获取1个许可证}@Overridepublic void unlock() {sync.releaseShared(1);  // 释放1个许可证}// 其他Lock方法实现...
}/*** 测试TwinsLock*/
public class TwinsLockTest {@Testpublic void testTwinsLock() {final Lock lock = new TwinsLock();// 启动10个线程，但同一时刻只有2个能获取锁for (int i = 0; i < 10; i++) {Thread worker = new Thread(() -> {lock.lock();try {System.out.println(Thread.currentThread().getName() + " 获取锁");Thread.sleep(1000);} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {lock.unlock();}});worker.start();}}
}

3. 重入锁ReentrantLock：可重复使用的智能锁

3.1 重入性：一把钥匙开多把锁

现实比喻：你进了自家大门，还可以用同一把钥匙打开卧室门、书房门。

/*** 重入锁的重入特性演示*/
public class ReentrantDemo {private final ReentrantLock lock = new ReentrantLock();public void outer() {lock.lock();try {System.out.println("外层方法获取锁，重入计数: " + getHoldCount());inner();  // 重入：同一个线程再次获取同一把锁} finally {lock.unlock();}}public void inner() {lock.lock();  // 这里不会阻塞，因为已经是锁的持有者try {System.out.println("内层方法获取锁，重入计数: " + getHoldCount());} finally {lock.unlock();}}private int getHoldCount() {// 返回当前线程持有该锁的次数return lock.getHoldCount();}
}

3.2 公平锁 vs 非公平锁

公平锁：像银行取号排队 - 先来先服务
非公平锁：像公交车抢座位 - 谁能抢到谁坐

/*** 公平性对比测试*/
public class FairVsUnfairTest {private static Lock fairLock = new ReentrantLock(true);      // 公平锁private static Lock unfairLock = new ReentrantLock(false);   // 非公平锁@Testpublic void comparePerformance() {// 测试结果通常显示：// - 公平锁：保证顺序，但性能较低// - 非公平锁：可能饥饿，但吞吐量高testLock("公平锁", fairLock);testLock("非公平锁", unfairLock);}private void testLock(String type, Lock lock) {long start = System.currentTimeMillis();// 多个线程竞争锁...long duration = System.currentTimeMillis() - start;System.out.println(type + " 耗时: " + duration + "ms");}
}

3.3 重入锁实现原理

/*** 重入锁核心实现解析*/
public class ReentrantLockCore {/*** 非公平锁获取逻辑*/final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {  // 锁空闲if (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}} else if (current == getExclusiveOwnerThread()) {  // 重入int nextc = c + acquires;if (nextc < 0) throw new Error("超过最大锁计数");setState(nextc);  // 增加重入计数return true;}return false;}/*** 释放锁逻辑*/protected final boolean tryRelease(int releases) {int c = getState() - releases;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;if (c == 0) {  // 完全释放free = true;setExclusiveOwnerThread(null);}setState(c);return free;}
}

4. 读写锁ReentrantReadWriteLock：读写分离的高并发锁

4.1 读写锁的应用场景

现实比喻：图书馆管理规则

读操作：多人可同时阅读同一本书
写操作：修改书籍时需独占访问

/*** 基于读写锁的缓存实现*/
public class ReadWriteCache<K, V> {private final Map<K, V> cache = new HashMap<>();private final ReadWriteLock rwLock = new ReentrantReadWriteLock();private final Lock readLock = rwLock.readLock();private final Lock writeLock = rwLock.writeLock();/*** 读操作：共享锁，允许多个线程同时读*/public V get(K key) {readLock.lock();try {String value = cache.get(key);// 模拟配置读取的耗时操作simulateProcess(1);return value;} finally {readLock.unlock();}}/*** 批量获取配置 - 读锁支持并发*/public Map<String, String> getConfigs(Set<String> keys) {readLock.lock();try {Map<String, String> result = new HashMap<>();for (String key : keys) {result.put(key, cache.get(key));}simulateProcess(keys.size());return result;} finally {readLock.unlock();}}/*** 更新配置 - 低频操作，使用写锁*/public void updateConfig(String key, String value) {writeLock.lock();try {// 模拟配置更新的耗时操作simulateProcess(10);cache.put(key, value);System.out.println("配置更新: " + key + " = " + value);} finally {writeLock.unlock();}}private void simulateProcess(int milliseconds) {try {Thread.sleep(milliseconds);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}
}

4.2 读写锁的状态设计

/*** 读写锁状态设计的精妙之处*/
public class ReadWriteStateDesign {/*** 32位state字段的划分：* * ┌─────────────────┬─────────────────┐* │     高16位      │     低16位      │* │     读状态      │     写状态      │* │   (读锁计数)    │  (写锁重入数)   │* └─────────────────┴─────────────────┘*/// 获取写状态（低16位）static int exclusiveCount(int c) { return c & 0x0000FFFF; }// 获取读状态（高16位）static int sharedCount(int c) { return c >>> 16; }// 读锁计数+1int newReadState = currentState + (1 << 16);  // 即 + 0x00010000// 写锁计数+1  int newWriteState = currentState + 1;
}

4.3 锁降级：保证数据可见性的重要技术

/*** 锁降级示例：写锁 → 读锁* 目的：保证数据的可见性*/
public class LockDemotionExample {private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();private final Lock readLock = rwLock.readLock();private final Lock writeLock = rwLock.writeLock();private volatile boolean update = false;private Object data;public void processData() {readLock.lock();if (!update) {// 数据需要更新，必须先释放读锁readLock.unlock();// 获取写锁writeLock.lock();try {// 双重检查if (!update) {// 准备数据...data = fetchData();update = true;}// 关键步骤：在释放写锁前获取读锁readLock.lock();  // 锁降级开始} finally {writeLock.unlock();  // 锁降级完成，现在持有读锁}}try {// 使用数据（仍在读锁保护下）useData(data);} finally {readLock.unlock();}}// 不支持锁升级！可能产生死锁public void invalidLockUpgrade() {readLock.lock();try {// 危险操作：尝试在持有读锁时获取写锁// 如果其他线程也持有读锁，会产生死锁writeLock.lock();  // 可能永远阻塞！try {// 修改数据...} finally {writeLock.unlock();}} finally {readLock.unlock();}}private Object fetchData() { return null; }private void useData(Object data) {}
}

5. LockSupport：线程的精准遥控器

5.1 LockSupport的核心能力

LockSupport提供线程阻塞和唤醒的原子操作，就像线程的远程控制器：

/*** LockSupport基础使用*/
public class LockSupportBasic {public static void main(String[] args) throws InterruptedException {Thread worker = new Thread(() -> {System.out.println("工作线程开始执行");System.out.println("工作线程即将被阻塞");// 阻塞当前线程（停车）LockSupport.park();System.out.println("工作线程被唤醒，继续执行");});worker.start();Thread.sleep(2000);  // 主线程等待2秒System.out.println("主线程准备唤醒工作线程");// 唤醒指定线程（开车）LockSupport.unpark(worker);System.out.println("主线程已发送唤醒信号");}
}

5.2 许可机制：先发后至的灵活性

/*** LockSupport的许可机制演示* 每个线程有一个许可（最多为1）：* - unpark：添加一个许可* - park：消耗一个许可，没有许可就阻塞*/
public class PermitMechanism {public static void main(String[] args) {Thread thread = new Thread(() -> {System.out.println("子线程开始");try {Thread.sleep(1000);  // 确保主线程先调用unpark} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println("子线程调用park");// 这里不会阻塞，因为主线程已经给了许可LockSupport.park();System.out.println("子线程第一次park完成");// 这次会阻塞，因为许可已经被消耗LockSupport.park(); System.out.println("子线程第二次park完成");});thread.start();// 立即给子线程许可（先发）System.out.println("主线程调用unpark");LockSupport.unpark(thread);// 等待后再次唤醒try {Thread.sleep(2000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println("主线程再次调用unpark");LockSupport.unpark(thread);}
}

5.3 Blocker：线程诊断的"身份证"

/*** Blocker的作用：在线程dump中标识等待目标*/
public class BlockerDemo {public static void main(String[] args) throws InterruptedException {Object blocker = new Object();  // 阻塞对象Thread withBlocker = new Thread(() -> {System.out.println("带Blocker的线程开始阻塞");// 推荐：使用带blocker的park方法LockSupport.park(blocker);  System.out.println("带Blocker的线程被唤醒");}, "WithBlocker-Thread");Thread withoutBlocker = new Thread(() -> {System.out.println("无Blocker的线程开始阻塞");// 不推荐：无blocker的park方法LockSupport.park();  System.out.println("无Blocker的线程被唤醒");}, "WithoutBlocker-Thread");withBlocker.start();withoutBlocker.start();Thread.sleep(1000);// 在实际环境中使用jstack查看线程dump，区别明显：// 有Blocker: "parking to wait for <0x00000000d5e8a6c0> (a java.lang.Object)"// 无Blocker: 只显示在LockSupport.park处等待LockSupport.unpark(withBlocker);LockSupport.unpark(withoutBlocker);withBlocker.join();withoutBlocker.join();}
}

6. Condition接口：精准的线程协调器

6.1 Condition vs Object监视器

特性	Object.wait/notify	Condition.await/signal
前置条件	必须在synchronized内	必须先获取Lock
等待队列	一个对象一个队列	一个Lock多个Condition
精确通知	只能notifyAll或随机	可以精确通知特定Condition
超时控制	有限支持	丰富的时间控制方法

6.2 Condition实战：有界阻塞队列

/*** 有界阻塞队列 - Condition的经典应用* 功能：* - 队列空时，消费者等待* - 队列满时，生产者等待*/
public class BoundedBlockingQueue<T> {private final Object[] items;private int addIndex, removeIndex, count;private final Lock lock = new ReentrantLock();private final Condition notEmpty = lock.newCondition();  // 非空条件private final Condition notFull = lock.newCondition();   // 非满条件public BoundedBlockingQueue(int capacity) {if (capacity <= 0) throw new IllegalArgumentException();items = new Object[capacity];}/*** 生产方法：队列满时阻塞*/public void put(T item) throws InterruptedException {lock.lock();try {// 使用while防止虚假唤醒while (count == items.length) {System.out.println("队列已满，生产者等待...");notFull.await();  // 在notFull条件上等待}// 生产元素items[addIndex] = item;if (++addIndex == items.length) addIndex = 0;count++;System.out.println("生产: " + item + ", 当前数量: " + count);// 通知可能等待的消费者notEmpty.signal();} finally {lock.unlock();}}/*** 消费方法：队列空时阻塞*/@SuppressWarnings("unchecked")public T take() throws InterruptedException {lock.lock();try {// 使用while防止虚假唤醒while (count == 0) {System.out.println("队列为空，消费者等待...");notEmpty.await();  // 在notEmpty条件上等待}// 消费元素T item = (T) items[removeIndex];if (++removeIndex == items.length) removeIndex = 0;count--;System.out.println("消费: " + item + ", 当前数量: " + count);// 通知可能等待的生产者notFull.signal();return item;} finally {lock.unlock();}}
}

6.3 Condition内部机制：等待队列与同步队列的协作

/*** Condition内部工作机制解析*/
public class ConditionInternalMechanism {/*** Condition内部有两个重要队列：* * 1. 等待队列（Condition队列）：单向链表*    firstWaiter → [thread|nextWaiter] → [thread|nextWaiter] → lastWaiter*    * 2. 同步队列（AQS队列）：双向链表  *    head ↔ [prev|thread|next] ↔ [prev|thread|next] ↔ tail* * await过程：同步队列 → 等待队列* signal过程：等待队列 → 同步队列*//*** await方法核心流程：*/public final void await() throws InterruptedException {// 1. 创建节点加入Condition等待队列Node node = addConditionWaiter();// 2. 完全释放锁（保存重入状态）int savedState = fullyRelease(node);// 3. 阻塞直到被signal或中断while (!isOnSyncQueue(node)) {LockSupport.park(this);if (checkInterruptWhileWaiting(node) != 0) break;}// 4. 被唤醒后重新竞争锁if (acquireQueued(node, savedState)) {// 处理中断...}}/*** signal方法核心流程：*/public final void signal() {// 1. 必须持有锁才能调用if (!isHeldExclusively())throw new IllegalMonitorStateException();// 2. 转移等待队列的第一个节点到同步队列Node first = firstWaiter;if (first != null)doSignal(first);}
}

7. AQS同步队列 vs Condition等待队列

7.1 核心区别总结

特性	AQS同步队列	Condition等待队列
设计目的	管理锁竞争的线程	管理条件等待的线程
数据结构	双向链表	单向链表
节点状态	SIGNAL, CANCELLED, 0, PROPAGATE	CONDITION(-2)
队列数量	每个AQS实例1个	每个Condition1个
线程行为	竞争锁资源	等待特定条件满足
唤醒方式	前驱节点释放锁时唤醒	其他线程调用signal()唤醒

7.2 队列协作的完整示例

/*** 演示两个队列如何协作工作*/
public class TwoQueuesCollaboration {private final ReentrantLock lock = new ReentrantLock();private final Condition condition = lock.newCondition();public void demonstrate() throws InterruptedException {Thread waiter = new Thread(() -> {lock.lock();try {System.out.println("Waiter: 获取锁，准备await");// 此时：// - Waiter在同步队列中（持有锁）// - 等待队列为空condition.await();  // 关键操作！// await内部完成：// 1. Waiter节点从同步队列移到等待队列// 2. 释放锁// 3. 阻塞等待System.out.println("Waiter: 被唤醒，重新获得锁");} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {lock.unlock();}});Thread signaler = new Thread(() -> {lock.lock();try {System.out.println("Signaler: 获取锁，调用signal");// 此时：// - Signaler在同步队列中（持有锁）  // - Waiter在等待队列中condition.signal();  // 关键操作！// signal内部完成：// 1. Waiter节点从等待队列移到同步队列// 2. 唤醒Waiter线程System.out.println("Signaler: signal完成");} finally {lock.unlock();  // 释放锁，Waiter有机会竞争锁}});waiter.start();Thread.sleep(100);  // 确保waiter先执行signaler.start();waiter.join();signaler.join();}
}

8. 实战指南：如何正确使用Java并发锁

8.1 锁使用的核心原则

原则1：永远在finally块中释放锁

/*** 正确的锁释放方式*/
public class CorrectLockUsage {private final Lock lock = new ReentrantLock();// ✅ 正确做法public void correctMethod() {lock.lock();try {// 业务逻辑doBusiness();} finally {lock.unlock();  // 确保锁被释放}}// ❌ 错误做法public void wrongMethod() {lock.lock();doBusiness();lock.unlock();  // 如果doBusiness抛出异常，锁不会被释放！}private void doBusiness() {// 可能抛出异常的业务逻辑if (Math.random() > 0.5) {throw new RuntimeException("业务异常");}}
}

原则2：避免锁嵌套，预防死锁

/*** 死锁预防示例*/
public class DeadlockPrevention {private final Lock lockA = new ReentrantLock();private final Lock lockB = new ReentrantLock();// ❌ 容易导致死锁的做法public void potentialDeadlock() {lockA.lock();try {// 一些操作...lockB.lock();  // 如果另一个线程以相反顺序获取锁，可能死锁try {// 更多操作...} finally {lockB.unlock();}} finally {lockA.unlock();}}// ✅ 使用tryLock避免死锁public void safeMethod() {while (true) {if (lockA.tryLock()) {try {if (lockB.tryLock()) {try {// 成功获取两个锁，执行业务doBusiness();return;  // 成功完成，退出循环} finally {lockB.unlock();}}} finally {lockA.unlock();}}// 获取锁失败，短暂休息后重试try {Thread.sleep(10);} catch (InterruptedException e) {Thread.currentThread().interrupt();break;}}}// ✅ 使用固定的锁获取顺序public void fixedOrderMethod(Object resource1, Object resource2) {// 通过hash值确定固定的获取顺序int hash1 = System.identityHashCode(resource1);int hash2 = System.identityHashCode(resource2);if (hash1 < hash2) {lockA.lock();lockB.lock();} else {lockB.lock();lockA.lock();}try {doBusiness();} finally {lockA.unlock();lockB.unlock();}}private void doBusiness() {}
}

8.2 各组件最佳实践案例

8.2.1 ReentrantLock最佳实践：连接池管理

/*** 基于ReentrantLock的简单数据库连接池* 特性：支持超时获取、中断响应、连接验证*/
public class DatabaseConnectionPool {private final LinkedList<Connection> pool = new LinkedList<>();private final ReentrantLock lock = new ReentrantLock(true);  // 公平锁private final Condition notEmpty = lock.newCondition();private final int maxSize;private final long maxWaitTime;public DatabaseConnectionPool(int maxSize, long maxWaitMillis) {this.maxSize = maxSize;this.maxWaitTime = maxWaitMillis;initializePool();}/*** 获取连接 - 支持超时和中断*/public Connection getConnection() throws InterruptedException, TimeoutException {lock.lock();try {long endTime = System.currentTimeMillis() + maxWaitTime;while (pool.isEmpty()) {long remainingTime = endTime - System.currentTimeMillis();if (remainingTime <= 0) {throw new TimeoutException("获取连接超时");}// 等待连接可用，支持超时if (!notEmpty.await(remainingTime, TimeUnit.MILLISECONDS)) {throw new TimeoutException("获取连接超时");}}// 获取并验证连接Connection conn = pool.removeFirst();if (!isConnectionValid(conn)) {conn = createNewConnection();}return conn;} finally {lock.unlock();}}/*** 归还连接*/public void returnConnection(Connection conn) {if (conn == null) return;lock.lock();try {if (pool.size() < maxSize && isConnectionValid(conn)) {pool.addLast(conn);notEmpty.signal();  // 通知等待的线程} else {// 连接池已满或连接无效，关闭连接closeConnection(conn);}} finally {lock.unlock();}}/*** 尝试获取连接（非阻塞）*/public Connection tryGetConnection() {if (lock.tryLock()) {try {if (!pool.isEmpty()) {Connection conn = pool.removeFirst();if (isConnectionValid(conn)) {return conn;}}} finally {lock.unlock();}}return null;}private boolean isConnectionValid(Connection conn) {// 连接有效性检查逻辑try {return conn != null && !conn.isClosed() && conn.isValid(2);} catch (SQLException e) {return false;}}private Connection createNewConnection() {// 创建新连接的逻辑return null; // 简化实现}private void closeConnection(Connection conn) {// 关闭连接的逻辑}private void initializePool() {// 初始化连接池for (int i = 0; i < maxSize / 2; i++) {pool.add(createNewConnection());}}
}

8.2.2 读写锁最佳实践：配置中心

/*** 基于读写锁的配置中心* 特性：高频读取，低频更新，保证数据一致性*/
public class ConfigurationCenter {private final Map<String, String> configs = new HashMap<>();private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();private final Lock readLock = rwLock.readLock();private final Lock writeLock = rwLock.writeLock();/*** 获取配置 - 高频操作，使用读锁*/public String getConfig(String key) {readLock.lock();try {String value = configs.get(key);// 模拟配置读取的耗时操作simulateProcess(1);return value;} finally {readLock.unlock();}}/*** 批量获取配置 - 读锁支持并发*/public Map<String, String> getConfigs(Set<String> keys) {readLock.lock();try {Map<String, String> result = new HashMap<>();for (String key : keys) {result.put(key, configs.get(key));}simulateProcess(keys.size());return result;} finally {readLock.unlock();}}/*** 更新配置 - 低频操作，使用写锁*/public void updateConfig(String key, String value) {writeLock.lock();try {// 模拟配置更新的耗时操作simulateProcess(10);configs.put(key, value);System.out.println("配置更新: " + key + " = " + value);} finally {writeLock.unlock();}}/*** 批量更新配置 - 写锁保证原子性*/public void updateConfigs(Map<String, String> newConfigs) {writeLock.lock();try {simulateProcess(newConfigs.size() * 5);configs.putAll(newConfigs);System.out.println("批量更新配置: " + newConfigs.size() + " 项");} finally {writeLock.unlock();}}/*** 热更新配置 - 使用锁降级保证数据一致性*/public void hotUpdateConfig(String key, String value) {// 先获取写锁进行更新writeLock.lock();try {// 更新配置configs.put(key, value);System.out.println("热更新配置: " + key + " = " + value);// 锁降级：在释放写锁前获取读锁readLock.lock();} finally {writeLock.unlock();  // 锁降级完成}try {// 在读锁保护下进行后续操作（如通知观察者、记录日志等）notifyConfigChange(key, value);logConfigChange(key, value);} finally {readLock.unlock();}}private void notifyConfigChange(String key, String value) {// 通知配置变更观察者simulateProcess(2);}private void logConfigChange(String key, String value) {// 记录配置变更日志simulateProcess(1);}private void simulateProcess(int milliseconds) {try {Thread.sleep(milliseconds);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}
}

8.2.3 Condition最佳实践：任务调度器

/*** 基于Condition的任务调度器* 特性：支持任务等待、超时控制、优雅关闭*/
public class TaskScheduler {private final PriorityBlockingQueue<Task> taskQueue = new PriorityBlockingQueue<>();private final ReentrantLock lock = new ReentrantLock();private final Condition taskAvailable = lock.newCondition();private final Condition schedulerStopped = lock.newCondition();private volatile boolean running = true;private final Thread workerThread;public TaskScheduler() {this.workerThread = new Thread(this::processTasks, "TaskScheduler-Worker");this.workerThread.start();}/*** 提交任务 - 支持超时*/public boolean submitTask(Task task, long timeout, TimeUnit unit) throws InterruptedException {lock.lock();try {long deadline = System.nanoTime() + unit.toNanos(timeout);// 等待直到有空间或超时while (taskQueue.size() >= 1000) {  // 队列容量限制long remaining = deadline - System.nanoTime();if (remaining <= 0) {return false;  // 超时}if (!taskAvailable.await(remaining, TimeUnit.NANOSECONDS)) {return false;  // 超时}}taskQueue.offer(task);taskAvailable.signal();  // 通知工作线程return true;} finally {lock.unlock();}}/*** 立即提交任务（非阻塞）*/public boolean submitTaskNow(Task task) {lock.lock();try {if (taskQueue.size() >= 1000) {return false;  // 队列已满}taskQueue.offer(task);taskAvailable.signal();return true;} finally {lock.unlock();}}/*** 优雅关闭 - 等待所有任务完成*/public void shutdown() throws InterruptedException {lock.lock();try {running = false;taskAvailable.signalAll();  // 唤醒工作线程// 等待任务队列清空while (!taskQueue.isEmpty()) {schedulerStopped.await(1, TimeUnit.SECONDS);}} finally {lock.unlock();}workerThread.join();}/*** 立即关闭*/public void shutdownNow() {lock.lock();try {running = false;taskQueue.clear();taskAvailable.signalAll();} finally {lock.unlock();}}private void processTasks() {while (running || !taskQueue.isEmpty()) {try {Task task = taskQueue.poll(1, TimeUnit.SECONDS);if (task != null) {executeTask(task);}} catch (InterruptedException e) {Thread.currentThread().interrupt();break;}}// 通知关闭完成lock.lock();try {schedulerStopped.signalAll();} finally {lock.unlock();}}private void executeTask(Task task) {try {task.execute();} catch (Exception e) {System.err.println("任务执行失败: " + e.getMessage());}}public static class Task implements Comparable<Task> {private final Runnable runnable;private final long scheduledTime;private final int priority;public Task(Runnable runnable, long delay, TimeUnit unit, int priority) {this.runnable = runnable;this.scheduledTime = System.nanoTime() + unit.toNanos(delay);this.priority = priority;}public void execute() {runnable.run();}@Overridepublic int compareTo(Task other) {int timeCompare = Long.compare(this.scheduledTime, other.scheduledTime);if (timeCompare != 0) {return timeCompare;}return Integer.compare(other.priority, this.priority);  // 优先级高的在前}}
}

8.2.4 LockSupport最佳实践：自定义同步器

/*** 基于LockSupport的自定义闭锁* 特性：一次性屏障，支持超时和中断*/
public class SimpleCountDownLatch {private volatile int count;private final Queue<Thread> waiters = new ConcurrentLinkedQueue<>();public SimpleCountDownLatch(int count) {if (count < 0) throw new IllegalArgumentException("计数不能为负");this.count = count;}/*** 等待闭锁打开*/public void await() throws InterruptedException {if (Thread.interrupted()) {throw new InterruptedException();}if (count <= 0) {return;  // 已经打开}// 使用LockSupport阻塞Thread current = Thread.currentThread();waiters.offer(current);// 双重检查避免错过信号if (count > 0) {LockSupport.park(this);}// 检查是否被中断唤醒if (Thread.interrupted()) {throw new InterruptedException();}}/*** 超时等待*/public boolean await(long timeout, TimeUnit unit) throws InterruptedException {if (Thread.interrupted()) {throw new InterruptedException();}if (count <= 0) {return true;}long deadline = System.nanoTime() + unit.toNanos(timeout);Thread current = Thread.currentThread();waiters.offer(current);try {while (count > 0) {long remaining = deadline - System.nanoTime();if (remaining <= 0) {return false;  // 超时}LockSupport.parkNanos(this, remaining);if (Thread.interrupted()) {throw new InterruptedException();}}return true;} finally {waiters.remove(current);}}/*** 计数减1*/public void countDown() {if (count <= 0) {return;  // 已经打开}if (--count == 0) {// 唤醒所有等待线程Thread waiter;while ((waiter = waiters.poll()) != null) {LockSupport.unpark(waiter);}}}/*** 获取当前计数*/public int getCount() {return count;}
}

8.3 性能优化和陷阱避免

8.3.1 锁性能优化技巧

/*** 锁性能优化实践*/
public class LockPerformanceOptimization {private final ReentrantLock lock = new ReentrantLock();private int counter = 0;private long lastLogTime = System.currentTimeMillis();// ❌ 锁粒度太粗public void coarseGrainedLock() {lock.lock();try {// 包含非临界区操作loadFromDatabase();  // 耗时IO操作counter++;           // 真正的临界区saveToDatabase();    // 耗时IO操作} finally {lock.unlock();}}// ✅ 锁粒度细化public void fineGrainedLock() {// 在锁外执行IO操作loadFromDatabase();lock.lock();try {counter++;  // 只保护真正的临界区} finally {lock.unlock();}saveToDatabase();  // 在锁外执行IO操作}// ✅ 使用原子变量替代锁private final AtomicInteger atomicCounter = new AtomicInteger(0);public void atomicOperation() {atomicCounter.incrementAndGet();  // 无锁操作，性能更高}// ✅ 读写分离private final ReadWriteLock rwLock = new ReentrantReadWriteLock();private final Lock readLock = rwLock.readLock();private final Lock writeLock = rwLock.writeLock();private volatile boolean initialized = false;public void lazyInit() {if (!initialized) {writeLock.lock();try {// 双重检查if (!initialized) {performInitialization();initialized = true;}} finally {writeLock.unlock();}}// 后续读操作使用读锁readLock.lock();try {useInitializedResource();} finally {readLock.unlock();}}private void loadFromDatabase() {// 模拟数据库加载}private void saveToDatabase() {// 模拟数据库保存}private void performInitialization() {// 初始化操作}private void useInitializedResource() {// 使用初始化后的资源}
}

8.3.2 常见陷阱及避免方法

/*** 并发编程常见陷阱及解决方案*/
public class ConcurrentPitfalls {// 陷阱1：在锁内调用外部方法（可能发生死锁）public void trap1() {ReentrantLock lock = new ReentrantLock();lock.lock();try {externalMethod();  // 危险！可能获取其他锁} finally {lock.unlock();}}// 解决方案：减少锁内代码，只包含必要的临界区操作public void solution1() {ReentrantLock lock = new ReentrantLock();// 在锁外准备数据Object data = prepareData();lock.lock();try {// 只执行必须同步的操作updateSharedState(data);} finally {lock.unlock();}}// 陷阱2：忘记在finally中释放锁public void trap2() {ReentrantLock lock = new ReentrantLock();lock.lock();if (someCondition()) {return;  // 忘记释放锁！}lock.unlock();}// 解决方案：使用try-finally模板public void solution2() {ReentrantLock lock = new ReentrantLock();lock.lock();try {if (someCondition()) {return;}// 其他操作} finally {lock.unlock();  // 确保释放}}// 陷阱3：在Condition.await()中使用if而不是whilepublic void trap3() throws InterruptedException {ReentrantLock lock = new ReentrantLock();Condition condition = lock.newCondition();boolean conditionMet = false;lock.lock();try {if (!conditionMet) {  // 错误！应该用whilecondition.await();}// 可能被虚假唤醒，条件仍未满足} finally {lock.unlock();}}// 解决方案：总是使用while循环检查条件public void solution3() throws InterruptedException {ReentrantLock lock = new ReentrantLock();Condition condition = lock.newCondition();boolean conditionMet = false;lock.lock();try {while (!conditionMet) {  // 正确！防止虚假唤醒condition.await();}// 条件确定满足} finally {lock.unlock();}}private boolean someCondition() {return Math.random() > 0.5;}private Object prepareData() {return new Object();}private void updateSharedState(Object data) {// 更新共享状态}private void externalMethod() {// 可能获取其他锁的外部方法}
}

8.4 监控和调试技巧

8.4.1 锁监控工具

/*** 锁监控和诊断工具*/
public class LockMonitor {/*** 监控锁竞争情况*/public static void monitorLockContention(ReentrantLock lock, String lockName) {new Thread(() -> {while (true) {try {Thread.sleep(5000);  // 每5秒检查一次System.out.printf("锁[%s]监控: %n", lockName);System.out.printf("  - 等待队列长度: %d%n", lock.getQueueLength());System.out.printf("  - 是否有等待线程: %b%n", lock.hasQueuedThreads());System.out.printf("  - 是否被当前线程持有: %b%n", lock.isHeldByCurrentThread());System.out.printf("  - 重入次数: %d%n", lock.getHoldCount());} catch (InterruptedException e) {Thread.currentThread().interrupt();break;}}}, "LockMonitor-" + lockName).start();}/*** 死锁检测*/public static void detectDeadlock() {ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();long[] threadIds = threadMXBean.findDeadlockedThreads();if (threadIds != null) {System.err.println("检测到死锁！");ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(threadIds);for (ThreadInfo threadInfo : threadInfos) {System.err.println("死锁线程: " + threadInfo.getThreadName());System.err.println("阻塞对象: " + threadInfo.getLockName());System.err.println("阻塞者: " + threadInfo.getLockOwnerName());}}}/*** 锁性能统计*/public static class LockStats {private final ReentrantLock lock;private long lockAcquireCount = 0;private long totalWaitTime = 0;private long maxWaitTime = 0;public LockStats(ReentrantLock lock) {this.lock = lock;}public void recordLockAcquire(long waitTime) {lockAcquireCount++;totalWaitTime += waitTime;maxWaitTime = Math.max(maxWaitTime, waitTime);}public void printStats() {System.out.printf("锁统计: %n");System.out.printf("  - 获取次数: %d%n", lockAcquireCount);System.out.printf("  - 平均等待时间: %.2fms%n", lockAcquireCount > 0 ? (double)totalWaitTime / lockAcquireCount : 0);System.out.printf("  - 最大等待时间: %dms%n", maxWaitTime);System.out.printf("  - 当前等待线程: %d%n", lock.getQueueLength());}}
}