ReentrantLock 源代码之我见

ReentrantLock，英文意思是可重入锁。从实际代码实现来说，ReentrantLock也是互斥锁（Node.EXCLUSIVE）。与互斥锁对应的的，还有共享锁Node.SHARED

ReentrantLock 集成了Lock接口，Lock接口主要功能有上锁lock()、尝试上锁tryLock()、规定时间内尝试上锁tryLock(long time, TimeUnit unit)、释放锁unlock()。

ReentrantLock有个内部的抽象类Sync，这个Sync类继承了AbstractQueuedSynchronizer类，内部定义了抽象上锁方法lock()，还有非公平尝试上锁nonfairTryAcquire(int acquires)，

尝试释放锁tryRelease(int releases) 、是否持有互斥锁isHeldExclusively()等方法。

Sync 有两个子类，非公平锁NonfairSync和公平锁FairSync。两个子类，都实现了抽象的方法上锁lock()，同时还有一个尝试上锁tryAcquire(int acquires)。在Sync的子类实现中，这个

tryAcquire(int acquires)的形参acquires都是1，表示加锁1次。这个加锁次数，维护在AQS里面的变量state中，这个后面会讲。

ReentrantLock 类内部，还有上锁lock()、尝试上锁tryLock()、规定时间内尝试上锁tryLock(long time, TimeUnit unit)、释放锁unlock()、获取加锁次数getHoldCount()

获取等待的条件hasWaiters()等。其中，最重要，也是最常用的，是lock()、unlock()、tryLock()这些。

----------------------------------------------------------------------------------------------------------------

挑主要的方法来讲。

先介绍上锁lock()。

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

在这个方法中，sync.lock（），是一个策略模式，由子类的实现而确定。如果子类是公平锁FairSync，则调用FairSync的lock()方法；否则，调用非公平锁

NonfairSync的lock()方法。

先看公平锁的lock()，代码如下

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

//加锁

public final void acquire(int arg) {
    //如果尝试上锁上锁，并且获取队列成功，则当前线程自中断。
    if (!tryAcquire(arg) &&       //这里的tryAcquire，由子类实现，如下面的代码2。从这里可以看出，非公平所，acquire获取锁的时候，会直接尝试获取锁。失败则加入资源队列
        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;
        }

公平锁，总是先选择第一个节点加锁。如果锁已经被当前线程持有，当前线程再次获取锁的时候，会成功，加锁次数+1。这里体现的，就是ReenTrantLock的可重入性。

下面介绍释放锁的方法。事实上，公平锁和非公平锁的释放，都是调用了父类Sync的方法

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

尝试释放锁，调用的是父类Sync的方法，如下：

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

下面介绍非公平锁

final void lock() {
            if (compareAndSetState(0, 1))   //先采用 CAS操作尝试获取锁，成功则把当前线程设置成排他（互斥）锁线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);                //否则，执行加锁操作。这里的加锁操作acquire(1)，和公平锁的代码一模一样。唯一的区别，是加锁时候调用的tryAcquire，各自实现而已。
        }
 
 protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);    //这里的nonfairTryAcquire ，直接是调用父类Sync的方法。

}

//非公平锁尝试获取锁。由此可见，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;
        }

由上面的公平锁和非公平锁的实现可以看到，实现大同小异，都是调用超类AQS的 acquire(int arg) 方法（acquire(int arg)是一个模板方法模式代码）。

不同的是，公平锁总是第一个节点才能获取到锁，这里并不符合计算机的资源最大使用思想。而非公平锁，则是由jvm调度。因此ReentrantLock默认使用的是非公平锁。

公平锁和非公平锁，都有各自的tryAcquire方法

ReentrantLock实现的基础，是AQS的虚拟双向队列CLH，具体表现在代码里，则是Node节点。AQS的队列有两种，一种是资源队列（用于唤醒等操作），一种条件队列（用于条件达到Condition）

Node节点，在AQS里面，是由volatile这个关键字，volatile同时又是内存言语。volatile的修饰，可以使功节点对于不同的线程即时可见。这是关键字，是并发的基础之一。

当一个线程想获取锁，被阻塞的时候，表现在代码里面，就是一个死循环for(；；)，直到当前线程所在的节点获取到锁。

这里是类似于监听事件的原理：利用Node节点的修饰符volatile的特性。当另一个节点a（线程）释放了锁的时候，另一个线程b马上可以检测到。如果是节点b是节点a的后驱节点，则节点b可以获取到锁，而b的后驱节点c

则需要等待b释放锁后，再通知后驱节点c。这样c节点的线程，就实际形成了阻塞。

　---------------------------------------------------------------

个人水平有限，请各位大佬指点。