JAVA并发之ReentrantLock源码（二）

　　上一篇我们讲到了ReentrantLock通过使用AQS框架实现了tryAcquire、tryRelease方法，从ReentrantLock层面分析源码，本次我们将进一步深入AQS类，查看AQS底层是如何实现线程同步的。

1.acquire()

　　首先自然从加锁开始看起，从lock.lock调用AQS中的acquire方法，我们已经进入了AQS源码层面，一个看起来很简洁的acquire如下：

    /**
     * Acquires in exclusive mode, ignoring interrupts.  Implemented
     * by invoking at least once {@link #tryAcquire},
     * returning on success.  Otherwise the thread is queued, possibly
     * repeatedly blocking and unblocking, invoking {@link
     * #tryAcquire} until success.  This method can be used
     * to implement method {@link Lock#lock}.
     *
     * @param arg the acquire argument.  This value is conveyed to
     *        {@link #tryAcquire} but is otherwise uninterpreted and
     *        can represent anything you like.
     */
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

　　acquire进行了如下的操作：

　　1、tryAcquire(arg)：尝试获取需要的资源，如果成功返回true，这个方法就完成啦，如果失败，将会进入下一个步骤

在这个方法是需要使用者自己实现的语意，可以查看上一篇博客中reentrantlock中的实现。

　　2、addWaiter(Node.EXCLUSIVE), arg)：新建一个当前线程的节点（独占），将其放入CLH队列中等待：

    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {//如果原来有头有尾
            node.prev = pred;//设置当前节点的前置节点
            if (compareAndSetTail(pred, node)) {//CAS尝试将其放入末尾
                pred.next = node;
                return node;
            }
        }
        enq(node);//当原来没头没尾的时候要同时CAS设置头尾节点为当前节点
        return node;
    }

    private Node enq(final Node node) {
        for (;;) {//自旋不断的用cas设置头尾节点
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

　　3、acquireQueued：会获取中断，如果中断了，就通过返回值true使acquire方法执行selfInterrupt()再将线程变成中断状态。让我们来看看acquireQueued内部的实现：

    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {//不断自旋
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {//如果当前节点的前一个节点排队排到了头的位置并且可以获取到资源
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())//判断是否需要去休息（如果是的话），就执行parkAndCheckInterrupt（）方法去休息
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             * 如果前一个节点已经变成 SIGNAL（会提醒下一个节点）状态，当前节点的线程就可以去“睡觉”了
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             * 如果前一个线程已经被取消了，那么将他们跳过不断重复
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             * 如果前一个节点没有变成SIGNAL状态，就把它置为signal状态
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);//通过park方法让当前线程阻塞
        return Thread.interrupted();//返回当前线程的中断情况
    }

　　到这里，acquire方法已经看完了，通过AQS简介以及ReentranLock的tryAcquire方法，我们基本理解了ReentranLock加锁的整个流程：

　　尝试获取资源->获取失败则加一个独占的节点到CLH队列排队->让前一个节点变为signal状态->把自己阻塞等待前一个节点唤醒（当然唤醒操作会在release中实现）。

 

　　相信看到这里，都会迫不及待的点开release方法查看当前线程是怎么被前一个线程唤醒的吧，那我们就一起来看一看！

    public final boolean release(int arg) {
        if (tryRelease(arg)) {//1
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
    private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {//找到下一个不是取消状态的节点
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)//节点不为空就把下一个节点唤醒
            LockSupport.unpark(s.thread);
    }

　　1、尝试释放资源（一般来说都是会成功的，除非被中断了）

　　2、找到头节点，如果头节点不为空，并且当前节点的等待状态不为0（有下一个节点改变过当前节点的等待状态）

　　3、unparkSuccessor方法找到下一个不是取消状态的节点，如果不是空，就把它唤醒

 

　　看完这个，结合三篇博客，我们对ReentranLock的流程，以及AQS在其中做了哪些重要的事情都弄明白了，也对使用AQS构造同步变量需要实现哪些方法有了一定的理解，虽然不一定能立刻上手实现一个，但是给你一个实现的同步器比如CountdownLatch等，查看它的内部实现一定不会出现翻源码绕晕的情况了。

　　那么本篇ReentranLock基于AQS层面的实现就到此结束啦，也算是填了之前挖的一个坑。