JUC-ReentrantLock 源码

先上源码

public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;

    // 内部使用的同步器
    private final Sync sync;

    // 构造函数，可以选择公平或非公平锁，默认为非公平锁
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    // 获取锁
    public void lock() {
        sync.lock();
    }

    // 可中断的获取锁
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    // 尝试获取锁，成功返回true，失败返回false
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    // 带超时时间的尝试获取锁，成功返回true，失败返回false
    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

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

    // 返回一个Condition对象
    public Condition newCondition() {
        return sync.newCondition();
    }

    // 获取当前线程持有锁的个数
    public int getHoldCount() {
        return sync.getHoldCount();
    }

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

    // 判断锁是否被任意线程持有
    public boolean isLocked() {
        return sync.isLocked();
    }

    // 获取同步器
    public final Sync getSync() {
        return sync;
    }

    // 抽象同步器
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        // 加锁
        abstract void lock();

        // 尝试非公平获取锁
        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) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

        // 尝试获取锁，可响应中断
        final void acquireInterruptibly(int arg) throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            if (!tryAcquire(arg))
                doAcquireInterruptibly(arg);
        }

        // 尝试获取锁，可响应中断和超时
        final boolean tryAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            return tryAcquire(arg) || doAcquireNanos(arg, nanosTimeout);
        }

        // 释放锁
        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;
        }

        // 是否独占锁
        final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        // 条件变量
        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        // 获取当前线程持有锁的个数
        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        // 非公平锁同步器
        static final class NonfairSync extends Sync {
            private static final long serialVersionUID = 7316153563782823691L;

            // 加锁
            final void lock() {
                if (compareAndSetState(0, 1))
                    setExclusiveOwnerThread(Thread.currentThread());
                else
                    acquire(1);
            }

            // 尝试获取锁
            protected final boolean tryAcquire(int acquires) {
                return nonfairTryAcquire(acquires);
            }
        }

        // 公平锁同步器
        static final class FairSync extends Sync {
            private static final long serialVersionUID = -3000897897090466540L;

            // 加锁
            final void lock() {
                acquire(1);
            }

            // 尝试获取锁
            protected final boolean tryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();
                if (c == 0) {
                    if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                } else if (current == getExclusiveOwnerThread()) {
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
        }
    }
}

ReentrantLock 是 Java 中的一个可重入锁，它提供了与 synchronized 相同的互斥性和内存可见性，但是它比 synchronized 更加灵活，可以实现更多高级的功能，如公平锁、可中断锁、多条件变量等。

下面是 ReentrantLock 的源码分析总结：

1. ReentrantLock 是一个可重入锁，它通过一个 int 类型的 state 变量来表示锁的状态，其中高 16 位表示持有锁的线程的数量，低 16 位表示当前线程重入的次数。

2. ReentrantLock 支持公平锁和非公平锁，默认情况下是非公平锁。公平锁会按照线程请求锁的顺序来获取锁，而非公平锁则会优先考虑已经在等待队列中的线程，从而可能导致新的线程插队获取锁。

3. ReentrantLock 支持可中断锁，即在等待锁的过程中可以响应中断信号，通过调用 lockInterruptibly() 方法来实现。

4. ReentrantLock 支持多条件变量，通过 Condition 接口来实现。每个 ReentrantLock 对象都可以创建多个 Condition 对象，用于实现不同的等待/通知机制。

5. ReentrantLock 内部使用了 AQS（AbstractQueuedSynchronizer）来实现锁的同步机制。AQS 是一个抽象类，它提供了一些基本的同步操作，如获取锁、释放锁、等待队列等，ReentrantLock 利用 AQS 的模板方法来实现自己的同步逻辑。

6. ReentrantLock 的 lock() 方法和 unlock() 方法是 ReentrantLock 的核心方法，它们通过调用 AQS 的 acquire() 和 release() 方法来实现锁的获取和释放。在 lock() 方法中，如果当前线程已经持有锁，则直接增加重入次数；否则，通过 AQS 的 acquire() 方法来获取锁。在 unlock() 方法中，如果当前线程还持有锁，则减少重入次数；否则，通过 AQS 的 release() 方法来释放锁。

7. ReentrantLock 的 tryLock() 方法是一个非阻塞的尝试获取锁的方法，它会立即返回获取锁的结果，而不会阻塞当前线程。如果获取锁成功，则返回 true；否则，返回 false。

8. ReentrantLock 的 tryLock(long timeout, TimeUnit unit) 方法是一个带超时时间的尝试获取锁的方法，它会在指定的时间内尝试获取锁，如果获取锁成功，则返回 true；否则，返回 false。

9. ReentrantLock 的 lockInterruptibly() 方法是一个可中断的获取锁的方法，它会在等待锁的过程中响应中断信号，如果当前线程被中断，则抛出 InterruptedException 异常。

10. ReentrantLock 的 Condition 接口提供了等待/通知机制，它可以让线程在等待某个条件成立时进入等待状态，并在条件成立时被唤醒。Condition 接口的实现类是 ConditionObject，它是 AQS 的内部类，用于实现等待队列的管理和线程的唤醒。

总结，ReentrantLock 是一个非常强大和灵活的锁，它提供了很多高级的功能，可以满足不同的同步需求。但是，由于它的实现比较复杂，使用时需要注意一些细节，避免出现死锁、饥饿等问题。