Reentrant源码分析

此文由ReentrantLock入口，深入AQS源码，探究ReentrantLock是怎么利用AQS来实现互斥锁以及可重入的功能。

Lock

//JUC顶级锁接口，定义锁的抽象功能
public interface Lock {
    
    //上锁接口，上锁过程中不可响应中断，不成功则等待，直到上锁成功为止
    void lock();
    
    //上锁接口，上锁过程中可以响应中断，如果发生中断，那么抛出异常
    void lockInterruptibly() throws InterruptedException;
    
    //尝试进行一次快速上锁，如果失败返回false，成功返回true
    boolean tryLock();

    //尝试进行N次上锁，失败就在指定时间内自旋重试
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    
    //解锁
    void unlock();
    
    //利用锁创建一个Condition对象，锁可以在这个Condition对象上等待
    Condition newCondition();
}

ReentrantLock

lock方法

下面以ReentrantLock构造方法默认的非公平锁为例，来分析整个上锁流程

//ReentrantLock.java    
public void lock() {
    sync.lock();
}
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
    final void lock() {
        // 尝试快速获取锁
        // 1) 获取成功设置锁独占线程为当前线程
        // 2) 获取失败,调用acquire继续获取锁的流程
        if (compareAndSetState(0, 1))
            //独占线程设置为当前线程
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

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

    //这个方法实现了锁重入
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        //判断如果当前持有锁，但是独占线程是当前线程进行c + acquires;操作，重入次数加1
        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;
    }
}

//AbstractQueuedSynchronizer.java
public final void acquire(int arg) {
    // 首先尝试使用ReentrantLock实现的tryAcquire方式获取锁，如果获取失败进行入戏操作
    // 1) 将当前线程作为互斥节点加入到等待队列的尾部
    // 2) 判断当前节点的是否是头结点，如果是头结点，再次尝试获取锁，如果再获取失败，进行park阻塞线程，等待unpark或者interrupt唤醒
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 这里线程自我中断执行的实际操作时仅仅只设置线程中断标志位，那么这里为什么要进行中断？
        // 答：这是因为在acquireQueued执行的时候会重置中断位，如果方法返回true代表之前被中断，而acquireQueued执行会重置中断标志位
        // 而acquireQueued只有被中断了才会返回true，而acquire是不响应中断的，所以这里要把中断标志位恢复成之前的中断状态，以免
        // 影响此线程其他部分的逻辑执行会依赖中断标志位。
        // 
        //此外可以参考acquireInterruptibly 这种响应中断的方式获取锁的实现，在被中断时直接抛出异常，以方便被外部捕获处理
        selfInterrupt();
}
 private Node addWaiter(Node mode) {
        //创建一个当前线程的节点
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        //尝试进行一次快速入队，所谓的快速入队就是判断pred != null的情况下进行入队。如果判断失败了需要使用自旋的方式入队，即调用enq方法，里面是死循环
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }
//入队成功后，需要自旋判断有没有被唤醒，正常唤醒(upark)还是中断唤醒,中断唤醒还需要返回被重置前的中断状态    
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  对原先head解除Gc引用链
                    failed = false;
                    return interrupted;
                }
                // 如果获取锁失败了，判断是否应该park，如果需要park那么调用parkAndCheckInterrupt进行park。park被唤醒后进行
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                //如果失败了。取消当前线程锁
                cancelAcquire(node);
        }
    }
private static boolean shouldParkAfterFailedAcquire(Node z, 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表明可以随时响应释放锁，node节点此时可以
            // 安全滴park在这里
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            //代码走到这里，说明前一个节点的状态是cancelled，此时需要跳过前面这些cancelled的节点，然后重试
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            //往前找到正确的头节点，然后对当前的node直接链接
            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.
             */
            // 代码走到这里，前一个节点的状态肯定是 0 或者 PROPAGATE
            // 这里把前一个节点的状态设置成Node.SIGNAL，在下次进入这个方法的时候会安全的park
            // 为什么这里不能够设置成Node.SIGNAL返回true？因为这里的设置操作可能会失败，这里可以加入for死循环判断直到
            // 设置成功了再返回true，但因为在调用这个方法的外层已经有了for死循环，所以这里就简单点设置就完事儿了
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
    private final boolean parkAndCheckInterrupt() {
        //这一行执行完会阻塞，可以被unpark或者interrupt唤醒
        LockSupport.park(this);
        // 如果是被interrupt唤醒的换那么需要重置线程中断位，因为LockSupport.park(this);会一直循环判断中断位，如果没有重置线程的中断位，
        // 那么在这个线程 下次进入这个代码块的时候 LockSupport.park(this);将不会进行阻塞，而实际上应是需要阻塞的，所以这里调用Thread.interrupted()
        // 获得当前中断你状态，且重置中断位。为什么要获取中断状态？前面已经解释了，因为要根据中断状态，恢复原先的中断标志位，不影响此线程其他部分依赖
        // 中断标志位部分的逻辑。
        return Thread.interrupted();
    }

至此Reentrantlock方法解析完了，总结一下整个过程：

1、lock方法进入以后，当前线程上来就抢锁，因为是非公平的嘛。

2、抢锁成功退出，抢锁失败进入acquire，acquire的逻辑里有非公平锁的tryAcquire方法

3、调用tryAcquire再次尝试获取锁

4、抢锁失败进入等待队列。

5、入队成功后for死循环判断当前节点的前一个节点是否是头节点,如果是头结点，那么尝试获取锁，这里为什么可以尝试获取锁？因为头结点的索即将释放。

6、获取锁失败，判断下是不是应该park阻塞，如果当前条件可以进行park，那么进行park操作阻塞线程，线程进入阻塞状态，等待被unpark或者interrupt唤醒。

unlock方法

//ReentrantLock.java    
public void unlock() {
    sync.release(1);
}
public final boolean release(int arg) {
    //尝试释放锁
    if (tryRelease(arg)) {
        Node h = head;
        //释放成功唤醒后续节点
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}
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;
}
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;
    // 当前节点也就是头结点的状态<0 ，需要在signal发出前清0，也就是说需要头结点状态为Cancelled 或者 0状态，
    // 因为在shouldParkAfterFailedAcquire会对Cannellced和0进行判断，如果为0会设置成Signal
    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;
    //下一个节点为空或者状态是取消，那么跳过这些节点，继续往后找状态小于等于0的节点
    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;
    }
    //当s不为空时，说明找到了要唤醒的节点，此时进行unpark进行唤醒。
    if (s != null)
        LockSupport.unpark(s.thread);
}