JAVA 使用AQS写一把可重入锁

要使用 AbstractQueuedSynchronizer (AQS) 实现一个可重入锁，你可以创建一个继承自AQS的子类，并实现其中的相关方法。一个简单的可重入锁示例如下：

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class ReentrantLock {

    private final Sync sync;

    public ReentrantLock() {
        sync = new Sync();
    }

    // 加锁
    public void lock() {
        sync.acquire(1);
    }

    // 释放锁
    public void unlock() {
        sync.release(1);
    }

    // 判断当前线程是否持有锁
    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }

    // AQS的子类，实现可重入锁的逻辑
    private static class Sync extends AbstractQueuedSynchronizer {

        // 判断当前线程是否持有锁
        protected boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        // 尝试获取锁
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, arg)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            } else if (Thread.currentThread() == getExclusiveOwnerThread()) {
                setState(getState() + arg);
                return true;
            }
            return false;
        }

        // 尝试释放锁
        protected boolean tryRelease(int arg) {
            int newState = getState() - arg;
            if (Thread.currentThread() != getExclusiveOwnerThread()) {
                throw new IllegalMonitorStateException();
            }
            boolean free = false;
            if (newState == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(newState);
            return free;
        }
    }
}

在这个例子中，ReentrantLock 类包含了一个内部类 Sync 继承自 AbstractQueuedSynchronizer。Sync 类实现了可重入锁的核心逻辑：

• tryAcquire(int arg) 方法尝试获取锁，如果当前线程是第一个持有锁的线程，会成功获取锁；如果当前线程已经持有锁，会增加锁的持有次数。
• tryRelease(int arg) 方法尝试释放锁，如果当前线程不是持有锁的线程会抛出异常，否则会递减锁的持有次数，直到持有次数为0时才释放锁。

使用示例：

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区代码
} finally {
    lock.unlock();
}

需要注意的是，在实际开发中，推荐使用 java.util.concurrent.locks.ReentrantLock 类，它已经提供了完整的实现并且性能优于自行实现的简单可重入锁。