当前位置：首页 > news >正文

从ReentrantLock到AQS：深入解析Java并发锁的实现哲学

news 2026/5/12 19:43:29

引言：为什么我们需要深入理解锁机制？

在Java并发编程的世界中，锁是协调多线程访问共享资源的核心机制。从早期的synchronized关键字到java.util.concurrent包中的各种高级锁，Java的并发工具一直在演进。本文将选择ReentrantLock作为切入点，深入分析其底层依赖的抽象队列同步器（AQS），揭示现代Java并发锁的设计哲学与实现原理。

第一部分：ReentrantLock的使用与特性

1.1 基础使用示例

publicclassReentrantLockDemo{privatefinalReentrantLocklock=newReentrantLock();privateintcounter=0;publicvoidincrement(){lock.lock();// 获取锁try{counter++;System.out.println("Counter: "+counter+" Thread: "+Thread.currentThread().getName());}finally{lock.unlock();// 释放锁}}// 尝试获取锁，带有超时机制publicbooleantryIncrement(longtimeout,TimeUnitunit){try{if(lock.tryLock(timeout,unit)){try{counter++;returntrue;}finally{lock.unlock();}}returnfalse;}catch(InterruptedExceptione){Thread.currentThread().interrupt();returnfalse;}}}

1.2 ReentrantLock的核心特性

可重入性：同一个线程可以多次获得同一把锁
公平性选择：支持公平锁和非公平锁两种模式
可中断的锁获取：支持在等待锁的过程中响应中断
超时机制：可以尝试在指定时间内获取锁
条件变量支持：可以创建多个Condition对象

第二部分：揭开AQS的神秘面纱

2.1 AQS的设计思想

AQS采用模板方法模式，将同步器的核心算法框架固定，而将一些具体操作留给子类实现。其核心是一个FIFO双向队列（CLH队列的变体）和一个表示同步状态的volatile变量。

// AQS简化版核心结构publicabstractclassAbstractQueuedSynchronizer{// 同步状态，子类通过CAS操作修改privatevolatileintstate;// 等待队列的头节点和尾节点privatetransientvolatileNodehead;privatetransientvolatileNodetail;// 内部Node类定义staticfinalclassNode{volatileintwaitStatus;// 等待状态volatileNodeprev;// 前驱节点volatileNodenext;// 后继节点volatileThreadthread;// 等待线程NodenextWaiter;// 条件队列的后继节点}}

2.2 同步状态（State）的妙用

AQS中的state字段是一个int类型的volatile变量，不同的同步器以不同的方式解释这个状态：

ReentrantLock：state表示持有锁的线程的重入次数
Semaphore：state表示当前可用的许可证数量
CountDownLatch：state表示还需要等待的事件数量
ReentrantReadWriteLock：高16位表示读锁数量，低16位表示写锁重入次数

第三部分：ReentrantLock如何基于AQS实现

3.1 公平锁与非公平锁的实现差异

// 非公平锁的实现staticfinalclassNonfairSyncextendsSync{finalvoidlock(){// 直接尝试获取锁，不检查队列if(compareAndSetState(0,1))setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);// 调用AQS的acquire方法}protectedfinalbooleantryAcquire(intacquires){returnnonfairTryAcquire(acquires);}}// 公平锁的实现staticfinalclassFairSyncextendsSync{finalvoidlock(){acquire(1);// 直接进入队列排队}protectedfinalbooleantryAcquire(intacquires){finalThreadcurrent=Thread.currentThread();intc=getState();if(c==0){// 关键区别：先检查队列中是否有等待的线程if(!hasQueuedPredecessors()&&compareAndSetState(0,acquires)){setExclusiveOwnerThread(current);returntrue;}}// 重入逻辑...returnfalse;}}

3.2 锁获取的完整流程

// AQS中的acquire方法publicfinalvoidacquire(intarg){if(!tryAcquire(arg)&&// 步骤1：尝试获取锁acquireQueued(addWaiter(Node.EXCLUSIVE),arg))// 步骤2&3：入队并等待selfInterrupt();// 步骤4：恢复中断状态}// 节点入队privateNodeaddWaiter(Nodemode){Nodenode=newNode(Thread.currentThread(),mode);// 快速入队：尝试直接添加到队尾Nodepred=tail;if(pred!=null){node.prev=pred;if(compareAndSetTail(pred,node)){pred.next=node;returnnode;}}enq(node);// 完整入队流程returnnode;}// 在队列中等待获取锁finalbooleanacquireQueued(finalNodenode,intarg){booleanfailed=true;try{booleaninterrupted=false;for(;;){finalNodep=node.predecessor();// 只有前驱节点是头节点时，才尝试获取锁if(p==head&&tryAcquire(arg)){setHead(node);p.next=null;// help GCfailed=false;returninterrupted;}// 检查并更新等待状态，可能需要阻塞if(shouldParkAfterFailedAcquire(p,node)&&parkAndCheckInterrupt())interrupted=true;}}finally{if(failed)cancelAcquire(node);}}

第四部分：条件变量（Condition）的实现原理

4.1 ConditionObject的内部结构

publicclassConditionObjectimplementsCondition{privatetransientNodefirstWaiter;// 条件队列头节点privatetransientNodelastWaiter;// 条件队列尾节点// 等待条件publicfinalvoidawait()throwsInterruptedException{if(Thread.interrupted())thrownewInterruptedException();Nodenode=addConditionWaiter();// 添加到条件队列intsavedState=fullyRelease(node);// 完全释放锁intinterruptMode=0;while(!isOnSyncQueue(node)){LockSupport.park(this);// 阻塞当前线程if((interruptMode=checkInterruptWhileWaiting(node))!=0)break;}// 被唤醒后重新获取锁if(acquireQueued(node,savedState)&&interruptMode!=THROW_IE)interruptMode=REINTERRUPT;if(node.nextWaiter!=null)unlinkCancelledWaiters();if(interruptMode!=0)reportInterruptAfterWait(interruptMode);}// 发出信号publicfinalvoidsignal(){if(!isHeldExclusively())thrownewIllegalMonitorStateException();Nodefirst=firstWaiter;if(first!=null)doSignal(first);// 将节点从条件队列转移到同步队列}}

4.2 条件队列与同步队列的交互

同步队列（获取锁的等待队列） 条件队列（等待条件的队列） head firstWaiter | | Node1 <-> Node2 <-> Node3 CNode1 -> CNode2 -> CNode3 | | tail lastWaiter signal()操作： 1. 将CNode1从条件队列移除 2. 将CNode1转移到同步队列尾部 3. 唤醒CNode1中的线程

第五部分：性能优化与最佳实践

5.1 锁优化策略

减少锁的持有时间：只在必要的时候持有锁
减小锁的粒度：使用更细粒度的锁
锁分离技术：如ReadWriteLock分离读锁和写锁
无锁编程：考虑使用CAS操作或并发容器

5.2 选择合适的锁策略

publicclassLockStrategyExample{// 场景1：高竞争环境下的公平性选择// 公平锁：保证顺序性，但吞吐量较低privatefinalReentrantLockfairLock=newReentrantLock(true);// 场景2：低竞争或追求最大吞吐量// 非公平锁：可能产生饥饿，但吞吐量高privatefinalReentrantLockunfairLock=newReentrantLock(false);// 场景3：读多写少的场景privatefinalReentrantReadWriteLockrwLock=newReentrantReadWriteLock();publicvoidreadOperation(){rwLock.readLock().lock();try{// 读操作，可以并发执行}finally{rwLock.readLock().unlock();}}publicvoidwriteOperation(){rwLock.writeLock().lock();try{// 写操作，独占执行}finally{rwLock.writeLock().unlock();}}}

5.3 诊断锁问题

// 使用ThreadMXBean诊断死锁publicclassDeadlockDetector{publicstaticvoiddetectDeadlock(){ThreadMXBeanthreadMXBean=ManagementFactory.getThreadMXBean();long[]threadIds=threadMXBean.findDeadlockedThreads();if(threadIds!=null){ThreadInfo[]threadInfos=threadMXBean.getThreadInfo(threadIds);for(ThreadInfothreadInfo:threadInfos){System.out.println("Deadlocked thread: "+threadInfo.getThreadName());System.out.println("Lock held: "+threadInfo.getLockName());System.out.println("Lock owner: "+threadInfo.getLockOwnerName());}}}}

第六部分：AQS在Java并发框架中的应用

6.1 基于AQS的同步器家族

同步器类	状态state的含义	使用场景
ReentrantLock	重入次数	互斥访问
Semaphore	可用许可数	资源池限制
CountDownLatch	剩余计数	多任务等待
CyclicBarrier	等待线程数	线程屏障
ReentrantReadWriteLock	读写状态	读写分离

6.2 自定义同步器示例

// 基于AQS实现一个简单的二元闭锁publicclassBinaryLatch{privatestaticclassSyncextendsAbstractQueuedSynchronizer{protectedinttryAcquireShared(intacquires){// 闭锁打开时返回1，否则返回-1returngetState()==1?1:-1;}protectedbooleantryReleaseShared(intreleases){// 打开闭锁setState(1);returntrue;}}privatefinalSyncsync=newSync();publicvoidawait()throwsInterruptedException{sync.acquireSharedInterruptibly(1);}publicvoidopen(){sync.releaseShared(1);}}