ReentrantLock 源代码之我见

 public void lock() {
        sync.lock();
    }

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

//加锁

public final void acquire(int arg) {
    //如果尝试上锁上锁，并且获取队列成功，则当前线程自中断。
    if (!tryAcquire(arg) &&       //这里的tryAcquire，由子类实现，如下面的代码2
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  
        selfInterrupt();     // 自中断
}

//通过自旋的方式获取同步状态。所谓自旋，说白了，就是死循环for(;;)。这个方法返回中断状态
//代码1

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)) {   //如果前驱节点是头节点并且获取锁成功，则把头节点设置成当前的节点。并且把前驱节点的next设置为null，方便gc。这里再次调用了tryAcquire

                setHead(node);
                p.next = null; // help GC     //注意这里的写法。因为当前节点已经成为头部节点，当前节点的线程关闭后，当前节点也会被回收。那么当前节点的前驱节点的next，需要设置成null，否则gc不会回收当前节点。
                failed = false;
                return interrupted;         //返回当前的节点的中断状态：false
            } 
            if (shouldParkAfterFailedAcquire(p, node) &&     //是否应该挂起失败的线程
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

//是否应该挂起失败的线程

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    //如果前驱节点，已经是SIGNAL，也就是-1，那么直接返回true，表示可以挂起。因为，前驱节点释放锁后，会唤醒后续的的节点
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    if (ws > 0) {        //如果前驱节点已经被注销，也就是waitStatus > 0（大于0 的只有被注销的状态），则执行下面的循环

        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        do {             //这里不断循环，直到前驱节点的状态<=0。当等于0的时候，表示没有状态。当小于0的时候，有-1 -2 -3三种情况。其中，-3是共享模式才有，表示节点可传播。-2则是表示节点是处于条件Condition队列。-1才表示节点处于等待队列。    
            node.prev = pred = pred.prev;   //其实就是常用的for循环的变种而已

        } 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.
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);   //采用CAS操作，设置前驱节点的状态为-1，表示释放锁后，会唤醒后驱节点
    }
    return false;
}

/挂起并设置中断

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

//代码4
//节点取消获取锁

private void cancelAcquire(Node node) {
    // Ignore if node doesn‘t exist
    if (node == null)
        return;

    node.thread = null;

    // Skip cancelled predecessors
    //这里跳过前驱节点。这里的实现挺巧妙的
    Node pred = node.prev;
    while (pred.waitStatus > 0)    //如果前驱节点的状态>0，也就是已经被取消了，则循环向前查找前驱节点，直到前驱节点的状态 < = 0，也就是SIGNAL -1状态或者PROPAGATE -2传播状态。传播状态只在共享模式下才有用
        node.prev = pred = pred.prev;

    // predNext is the apparent node to unsplice. CASes below will
    // fail if not, in which case, we lost race vs another cancel
    // or signal, so no further action is necessary.
    Node predNext = pred.next;    //前驱节点的后驱节点

    // Can use unconditional write instead of CAS here.
    // After this atomic step, other Nodes can skip past us.
    // Before, we are free of interference from other threads.
    node.waitStatus = Node.CANCELLED;   //设置当前节点状态为取消，也就是1

    // If we are the tail, remove ourselves.
    if (node == tail && compareAndSetTail(node, pred)) {   //如果当前节点是末尾节点，当前节点n会被设置成CANCEL，则把等待队列的末尾节点设置成当前节点的前驱节点，也就是第n-1个节点被设置成了末尾节点
        compareAndSetNext(pred, predNext, null);            //将前驱节点的后驱节点设置为null，因为当前节点已经设置成了CANCELLED了，前驱节点正式成为末尾节点，也就不会再由后驱节点
    } else {
        // If successor needs signal, try to set pred‘s next-link
        // so it will get one. Otherwise wake it up to propagate.
        int ws;
        if (pred != head &&  //这里的说明，在下面说明1处详述
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            Node next = node.next;   //当前节点的后驱节的成下一个节点
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);       //前驱节点的后驱节点本来是当前节点，现在将前驱节点的后驱节点，设置成当前节点的下一个节点。
        } else {     //直接后激活驱节点。park是挂起unpark是激活 
            unparkSuccessor(node);
        }

        node.next = node; // help GC          //将节点的后驱节点设置成自身，方便gc。这里要注意的是，不同于其他变量，设置成null
    }
}

//说明1：如果当前节点不是头节点且线程不是空，有以下几种场景：1、前驱节点的状态已经是唤醒状态SIGNAL -1, 2、如果前驱节点不是SINGAL，会可能=0（没有状态） 或者=-3（共享模式的传播状态）,则设置前驱节点的状态为SIGNAL

//代码5
//激活后驱节点（使后驱节点可用）

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)          //如果当前节点的状态<0，即唤醒SINGAL -1状态 ，或者等待条件CONDITION -2状态 ，或者PROPAGATE -3 传播状态（共享模式），则将节点的状态设置成0（没有状态）
        compareAndSetWaitStatus(node, ws, 0);

    /*要激活的线程通常是在后驱节点上持有（这句话怎么意思？我的理解是，当前节点的后驱节点持有的线程，会被激活。也就是后驱节点的线程，会变成可用状态）。
     *如果后驱节点已经被取消或者被设置成null，则从末尾节点开始往前搜索，直接找到一个不是null又不是取消的节点。
     * 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)   //这里从末尾节点开始循环，直到当前节点的下一个非CANCEL&非null的节点，可以参考下图
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);            //使后驱节点持有的线程可用。但是只是使线程可用，不保证线程会被执行。
}

//代码2
protected final boolean tryAcquire(int acquires) {
            //先拿到当前线程
            final Thread current = Thread.currentThread();
            //获取上锁的次数
            int c = getState();
            if (c == 0) {    //如果上锁次数为0，则证明锁空闲
                if (!hasQueuedPredecessors() &&      //如果没有前驱节点Node，则证明当前节点是头节点。使用CAS方法，设置上锁次数。这个的次数，保存在AQS的state里面
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);  //设置锁的持有者为当前线程
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {   //如果锁由当前线程持有，则上锁次数+acquires。这个acquires总是1
                int nextc = c + acquires;
                if (nextc < 0)  //校验参数合法行
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);  //设置加锁次数
                return true;
            }
            return false;
        }

public void unlock() {
        sync.release(1);  //这里调用的是父类AQS的释放锁的方法
    }

//释放锁
 public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;            //因为是公平锁，永远是头节点获取到锁，也就永远从头节点开始释放锁
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);   //代码5的激活后驱节点线程
            return true;
        }
        return false;
    }

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;         //加锁次数叠减。这里的releases总是1
            if (Thread.currentThread() != getExclusiveOwnerThread())   //如果释放锁的线程不是排他锁的持有线程，则抛出异常
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);        //如果加锁次数已经是0，则设置锁的持有现场为null
            }
            setState(c);          //设置加锁次数
            return free;
        }

//非公平锁尝试获取锁。由此可见，ReentrantLock的默认锁，是非公平锁。

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();   //获取当前线程
            int c = getState();                //确认加锁次数。加锁次数维护在超类AQS的state里。这个state 是由volatile里（注意这个volatile内存言语的作用，是用于共享变量在多线程即时可见。
                                               //也就是一个线程改变了state，另一个线程马上能够看见。这个内存言语，是实现并发的基础之一）
            if (c == 0) {    //加锁次数为0，证明锁还没有被获取                  
                if (compareAndSetState(0, acquires)) {        //CAS操作，加锁。这里的acquires在ReentrantLock里，总是1
                    setExclusiveOwnerThread(current);         //设置当前线程持有排他锁    
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {     //如果加锁次数大于1，且是当前线程持有锁，则加锁次数累加
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);                         //设置加锁次数
                return true;
            }
            return false;
        }