可重入锁ReentrantLock解析

说到可重入锁，先从AQS的ConditionObject说起，AQS的内部类ConditionObject是构建显示锁条件队列的基础。之前AQS的解析没有说这个内部类，这里和ReentrantLock一起说一下。

1、AQS的内部类ConditionObject

addConditionWaiter方法的代码：

这个方法的作用是将当前线程封装好放到条件队列。

    private Node addConditionWaiter() {
            Node t = lastWaiter;
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {//如果等待队列的最后一个是取消状态，就把遍历整个队列把所有取消状态的节点清除
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            Node node = new Node(Thread.currentThread(), Node.CONDITION);//以当前线程新建一个节点
            if (t == null)//根据条件将节点放入队列
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;//返回当前线程的节点
        }

doSignal方法的代码：

这个方法的作用就是唤醒当前线程。

        private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&//调用了transferForSignal方法
                     (first = firstWaiter) != null);
        }

transferForSignal方法的代码：

    final boolean transferForSignal(Node node) {
        /*
         * If cannot change waitStatus, the node has been cancelled.
         */
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))//cas修改值，如果成功等待到了条件成立；如果失败节点的状态改为了CANCELLED，直接返回
            return false;

        /*
         * Splice onto queue and try to set waitStatus of predecessor to
         * indicate that thread is (probably) waiting. If cancelled or
         * attempt to set waitStatus fails, wake up to resync (in which
         * case the waitStatus can be transiently and harmlessly wrong).
         */
        Node p = enq(node);//节点入队 这里可能会有点晕，这个节点不是刚从队列里取出吗，怎么又入队了 其实是因为队列不是同一个，每个ConditionObject对象都有一个条件队列，队列里的节点等待的条件成立了会被添加到AQS的队列，这时节点（线程）才有资格等待获取资源
        int ws = p.waitStatus;
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))//唤醒线程
            LockSupport.unpark(node.thread);
        return true;
    }

doSignalAll方法的代码：

这个方法的作用就是唤醒所有节点（线程）。

        private void doSignalAll(Node first) {
            lastWaiter = firstWaiter = null;
            do {
                Node next = first.nextWaiter;
                first.nextWaiter = null;
                transferForSignal(first);
                first = next;
            } while (first != null);
        }

unlinkCancelledWaiters方法的代码：

这个方法被上面说的addConditionWaiter方法调用，将队列的取消状态的节点（线程）清除。

        private void unlinkCancelledWaiters() {
            Node t = firstWaiter;
            Node trail = null;
            while (t != null) {
                Node next = t.nextWaiter;
                if (t.waitStatus != Node.CONDITION) {
                    t.nextWaiter = null;
                    if (trail == null)
                        firstWaiter = next;
                    else
                        trail.nextWaiter = next;
                    if (next == null)
                        lastWaiter = trail;
                }
                else
                    trail = t;
                t = next;
            }
        }

doSignal方法的代码：

        public final void signal() {//唤醒一个节点（线程）
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

doSignalAll方法的代码：

        public final void signalAll() {//唤醒所有节点
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignalAll(first);
        }

awaitUninterruptibly方法的代码：

这个方法的作用就是将节点（线程）放入条件队列。

        public final void awaitUninterruptibly() {
            Node node = addConditionWaiter();//放入条件队列
            int savedState = fullyRelease(node);//释放资源
            boolean interrupted = false;
            while (!isOnSyncQueue(node)) {//当前节点是否在同步队列（在条件队列被唤醒后进入）
                LockSupport.park(this);//如果不在，等待
                if (Thread.interrupted())//检查是被中断还是被唤醒
                    interrupted = true;//如果是被中断设置interrupted，下面会设置中断标志
            }
            if (acquireQueued(node, savedState) || interrupted)//尝试获取资源 设置中断标志
                selfInterrupt();
        }

await方法的代码：

await方法和awaitUninterruptibly方法很相似，不同的地方是中断的处理。await方法的节点（）线程如果是中断结束等待的，会根据当前中断的处理模式判断是抛出异常还是保留中断标志，不会再尝试获取资源。

        public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)//如果是中断，break
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);//抛出异常或保留中断标志
        }

 ConditionObject的代码先说到这，下面说说ReentrantLock的代码。

2、ReentrantLock

ReentrantLock是独占模式的AQS，ReentrantLock有三个内部类，一个是抽象内部类。三个内部类为Sync、NonfairSync和FairSync。后面两个继承自前面一个。下面先说说这三个内部类。

Sync：

nonfairTryAcquire方法：

该方法的作用就是非公平地获取资源。

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {//如果没有线程占有资源
                if (compareAndSetState(0, acquires)) {//如果cas获取资源成功
                    setExclusiveOwnerThread(current);//将当前线程设置为独占资源的线程
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {//如果当前线程是占有资源的线程
                int nextc = c + acquires;//增加state ReentrantLock里acquires都传1 state为n说明当前线程重入的次数为n - 1
                if (nextc < 0)//溢出
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);//设置state值
                return true;
            }
            return false;
        }

tryRelease方法：

该方法的作用就是释放资源（锁），如果资源值（state）为0，则说明调用unlock的次数和调用lock的次数一样，锁可以释放供其它线程获取。

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())//如果当前线程不是独占占有资源的线程
                throw new IllegalMonitorStateException();//抛出异常
            boolean free = false;
            if (c == 0) {//如果c等于0 资源全部释放（也就是释放了锁）
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);//设置state的值
            return free;//返回是否释放了锁
        }

newCondition方法：

该方法的作用就是创建新的条件队列。

        final ConditionObject newCondition() {
            return new ConditionObject();
        }

NonfairSync：

lock方法：

非公平获取锁，每个线程获取锁时都会先cas试一下，如果成功了就直接获取了锁，不用再从入队出队开始。

        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);//如果不成功还要排队继续
        }

tryAcquire方法：

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }

FairSync：

lock方法：

公平获取锁，直接调用acquire，从入队出队开始。

        final void lock() {
            acquire(1);
        }

tryAcquire方法：

tryAcquire方法和nonfairTryAcquire方法类似，主要区别在于tryAcquire要求获取资源的节点（线程）必须是队首节点。

        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {//如果没有前驱节点（线程）且cas设置state成功，当前节点（线程）独占占有锁
                    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;
        }

说完了内部类，再看看几个提供的方法。

    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);
    }

    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    public Condition newCondition() {
        return sync.newCondition();
    }

会发现这些方法基本上都是直接调用上面或之前说的那些方法。