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

AQS的重入机制和锁释放逻辑

news 来源：原创 2025/6/9 10:43:47

学海无涯，志当存远。燃心砺志，奋进不辍。

愿诸君得此鸡汤，如沐春风，事业有成。

若觉此言甚善，烦请赐赞一枚，共励学途，同铸辉煌！

AQS的基本结构。
AQS通过一个FIFO队列来管理等待线程，并使用一个状态变量（state）来表示锁的状态。
对于重入锁（如ReentrantLock），重入意味着同一个线程可以多次获取锁，而不会导致死锁。
那么，AQS是如何跟踪重入次数的呢？
答案应该与状态变量state有关。每次重入，state会增加，释放时则递减，直到state为0时完全释放锁。

接下来，如何释放锁。释放锁的过程应该涉及到将state递减，并且唤醒队列中的后续线程。
但具体步骤是怎样的呢？需要详细说明AQS中tryRelease方法的实现，特别是在ReentrantLock中的应用。

需要讲解state的作用、exclusiveOwnerThread的作用，以及重入时如何维护这些变量。
同时，用户可能对释放锁时如何确保完全释放（即state归零）以及如何传递释放信号给其他线程感兴趣。

另外，锁释放的问题，比如忘记释放锁导致死锁，或者不理解为什么需要多次unlock。
因此，回答中需要强调重入锁的释放次数必须与获取次数匹配，否则可能导致状态不一致。

可能的误区包括：认为每次lock()后只需一次unlock()，而实际上需要相同次数的unlock()。
此外，用户可能不清楚AQS是如何处理非重入锁和重入锁的区别的，因此需要对比说明。

代码示例，比如ReentrantLock中的Sync类如何实现tryAcquire和tryRelease，
以及这些方法如何操作state和exclusiveOwnerThread。
同时，应该解释AQS的队列管理机制在释放锁时如何唤醒后续线程。

最后，总结重入机制的关键点和释放锁的正确方式，帮助用户巩固理解，避免常见错误。

在Java并发框架中，AbstractQueuedSynchronizer（AQS）是实现锁和其他同步器的核心基类。其重入机制和锁释放逻辑是理解可重入锁（如ReentrantLock）的关键。以下是详细说明：

一、AQS的重入机制实现

重入（Reentrancy）指同一个线程可以多次获取同一把锁，而不会导致死锁。

AQS通过以下方式实现重入：

线程持有状态（state）：AQS使用一个state变量来表示锁的持有状态。在独占锁（如ReentrantLock）的情况下，state变量记录锁被持有的次数。当一个线程尝试获取锁时，AQS会检查当前线程是否已经持有锁（即exclusiveOwnerThread == currentThread）。如果是同一个线程，则允许该线程再次获取锁，表示“可重入”。
重入计数：每次同一个线程获取锁时，state变量会递增，表示锁的重入次数。相应地，每次释放锁时，state变量会递减，直到state变为0时，锁才会真正释放。
线程引用：AQS通过内部的一个线程引用exclusiveOwnerThread来跟踪当前持有锁的线程。当一个线程第一次获取锁时，AQS会将exclusiveOwnerThread设置为该线程，并将state从0设置为1。如果同一线程再次尝试获取锁，AQS看到exclusiveOwnerThread已经是当前线程，于是允许锁的重入，并将state递增。

1. 状态变量 `state`

state 表示锁的持有次数：
- state = 0：锁未被任何线程持有
- state > 0：锁被某个线程持有，数值表示重入次数

关键代码（以ReentrantLock为例）：

final static class Sync extends AbstractQueuedSynchronizer {
    // 尝试获取锁（重入逻辑）
    protected final boolean tryAcquire(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()) { 
            // 当前线程已持有锁（重入）
            setState(c + acquires); // 增加重入次数
            return true;
        }
        return false;
    }
}

2. 独占线程标记 `exclusiveOwnerThread`

记录当前持有锁的线程。
重入时检查线程一致性，确保只有持有锁的线程能再次获取。

二、锁的释放过程

释放锁需要匹配获取次数，AQS通过tryRelease实现：

修改状态：首先，线程会修改AQS的state状态，将其递减。如果递减后state变为0，则表示锁已经完全释放。
通知等待线程：接着，线程会检查队列是否为空以及队头的waitStatus是否为0。如果waitStatus不为0（通常表示有线程在等待），则线程会通知队列中的下一个线程来获取锁。这是通过unparkSuccessor方法实现的，该方法会找到队列中离队头最近的、状态合适的节点，并将其唤醒。

1. 释放锁的核心逻辑

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; // 返回是否彻底释放
}

2. 释放后的队列处理

若tryRelease返回true（即state归零），AQS会唤醒等待队列中的下一个线程。

代码触发点：

public final boolean release(int arg) {
    if (tryRelease(arg)) { // 完全释放
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h); // 唤醒后续线程
        return true;
    }
    return false;
}

三、重入与释放的匹配规则

操作	重入次数变化	锁状态
`lock()`	`state += 1`	被当前线程持有
`unlock()`	`state -= 1`	若`state=0`则完全释放
关键要求	必须成对调用	否则导致死锁或状态异常

四、示例代码：重入锁的获取与释放

ReentrantLock lock = new ReentrantLock();

lock.lock();  // state=1
try {
    // 临界区代码...
    lock.lock();   // 重入，state=2
    try {
        // 嵌套临界区代码...
    } finally {
        lock.unlock(); // state=1
    }
} finally {
    lock.unlock(); // state=0（完全释放）
}

五、常见问题与注意事项

释放次数不匹配：
- 多调用一次unlock()：抛出IllegalMonitorStateException
- 少调用一次unlock()：锁未完全释放，其他线程无法获取
非重入锁的对比：
- 若AQS不实现重入逻辑，同一线程第二次调用lock()会直接进入等待队列。
设计意义：
- 支持递归调用（如递归方法中需要加锁）
- 避免同一线程重复获取锁时的死锁