// ReentrantLock.lockInterruptibly()
// 相当于ReentrantLock.lock()
public void lockInterruptibly() throws InterruptedException {
    // 这里调用的sync的acquireInterruptibly()方法，该方法是sync继承自AbstractQueuedSynchronizer的方法，由抽象类AbstractQueuedSynchronizer实现
    sync.acquireInterruptibly(1);
}
 
// AbstractQueuedSynchronizer.acquireInterruptibly()
// 相当于acquire(int arg)方法
public final void acquireInterruptibly(int arg) throws InterruptedException {
    // 在第一次调用acquireInterruptibly时，如果发现当前线程已经被中断了，则直接抛出中断异常，响应中断
    if (Thread.interrupted())
        throw new InterruptedException();
    
    // 尝试获取锁
    // 这里调用的sync的tryAcquire()方法，它的具体实现是根据当前ReentrantLock是公平锁还是非公平锁来决定的
    // 如果当前sync是公平锁tryAcquire()方法就是使用的FairSync实现类中的tryAcquire()实现方法，如果当前是非公平锁，则使用的是NonfairSync实现类中的tryAcquire()方法，也就是nonfairTryAcquire()方法
    if (!tryAcquire(arg))
        // 尝试获取所失败之后
        doAcquireInterruptibly(arg);
}

// AbstractQueuedSynchronizer.doAcquireInterruptibly()
// 相当于acquireQueued(addWaiter(Node.EXCLUSIVE), arg))，将获取锁失败的线程添加到等待队列并阻塞
private void doAcquireInterruptibly(int arg) throws InterruptedException {
    // 为当前线程创建Node线程节点，并将其入队
    final Node node = addWaiter(Node.EXCLUSIVE);
    // 入队之后，开始对线程进行阻塞
    // 阻塞线程是否失败
    boolean failed = true;
    try {
        // 自旋
        for (;;) {
            // 获取当前节点的前一个节点
            final Node p = node.predecessor();
            // 如果当前节点是等待队列中的第一个线程节点，则调用tryAcquire()尝试获取锁
            if (p == head && tryAcquire(arg)) {
                // 尝试获取锁成功，下面就需要将当前节点的node出队
                // 将head指针节点指向node，并且将node节点的前驱节点和代表的线程属性都设置为null
                setHead(node);
                p.next = null; // help GC
                // 将阻塞标志设置为false，说明没有阻塞节点线程
                failed = false;
                // 1.这里没有中断标识，也就没有返回中断标志，而是直接返回结束方法
                // lock和lockInterruptibly区别就是对中断的处理方式 
                return;
            }
            // shouldParkAfterFailedAcquire：判断线程可否安全阻塞
            // parkAndCheckInterrupt：挂起线程并返回当时中断标识Thread.interrupted()
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 2.当parkAndCheckInterrupt返回中断标识为true时立即抛出异常中断线程，而不是和lock()一样记录中断标志，等到获取锁成功之后再响应中断
                throw new InterruptedException();
        }
 
	// finally的执行一定会在throw new InterruptedException();抛出异常之前执行。finally代码块中的代码不管什么情况下，一定会被执行的
    } finally {
 
		/**
         * failed标识当前线程的阻塞有没有失败
         * doAcquireInterruptibly()最初始把failed设置为true，只有进入到成功获取到锁的分支中，才会将failed设置为false。
         * 所以除了成功获取锁return导致try{}执行结束以外，其他任何情况导致try{}执行结束都会使failed仍然等于true，也就是没有成功将线程阻塞过
         * 
         * waitStatus = CANCELLED =  1，表示线程已被取消（等待超时或者被中断），需要废弃结束。
         * 说的就是这种情况，当一个线程在doAcquireInterruptibly()方法中因为被中断（响应中断的方法lockInterruptibly()在识别到终端信号之后会直接抛出异常就会将try{}代码块执行结束掉）或等待超时等原因而提前结束，就需要将该线程node节点生命状态设置为CANCELLED
         * 在未来该节点的后继节点进入到shouldParkAfterFailedAcquire()方法时，就会将该节点给移出队列
         */
        // 如果阻塞线程失败了
        if (failed)
            // 取消获取锁，标注当前节点的生命状态为canceld信号量，这种状态的节点应该剔除
            cancelAcquire(node);
    }
}

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 获取锁成功后，中断当前线程。默认处理中断方式
        selfInterrupt();
}

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;
                // 1.在独占锁后，才返回中断标识
                return interrupted;
            }
            //shouldParkAfterFailedAcquire：判断线程可否安全挂起
            //parkAndCheckInterrupt：挂起线程并返回当时中断标识Thread.interrupted()
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 2.当parkAndCheckInterrupt返回中断标识为true时修改interrupted
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}