(转)ReentrantLock代码剖析之ReentrantLock.lockInterruptibly
ReentrantLock.lockInterruptibly允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回，这时不用获取锁，而会抛出一个InterruptedException。而ReentrantLock.lock方法不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试获取锁，失败则继续休眠。只是在最后获取锁成功后再把当前线程置为interrupted状态。

那lockInterruptibly是如何做到这一点的？

   public void lockInterruptibly() throws InterruptedException {        sync.acquireInterruptibly(1);    }

这里调用了AbstractQueuedSynchronizer.acquireInterruptibly方法。如果线程已被中断则直接抛出异常，否则则尝试获取锁，失败则doAcquireInterruptibly

AbstractQueuedSynchronizer.acquireInterruptibly(int arg) /**     * Acquires in exclusive mode, aborting if interrupted.     * Implemented by first checking interrupt status, then invoking     * at least once {@link #tryAcquire}, returning on     * success.  Otherwise the thread is queued, possibly repeatedly     * blocking and unblocking, invoking {@link #tryAcquire}     * until success or the thread is interrupted.  This method can be     * used to implement method {@link Lock#lockInterruptibly}.     *     * @param arg the acquire argument.  This value is conveyed to     *        {@link #tryAcquire} but is otherwise uninterpreted and     *        can represent anything you like.     * @throws InterruptedException if the current thread is interrupted     */    public final void acquireInterruptibly(int arg) throws InterruptedException {        if (Thread.interrupted())            throw new InterruptedException();        if (!tryAcquire(arg))            doAcquireInterruptibly(arg);    }

AbstractQueuedSynchronizer.doAcquireInterruptibly大体上相当于前面的acquireQueued,关键的区别在于检测到interrupted后的处理，acquireQueued简单的记录下中断曾经发生，然后就象没事人似的去尝试获取锁，失败则休眠。而doAcquireInterruptibly检测到中断则直接退出循环，抛出InterruptedException异常。

AbstractQueuedSynchronizer.doAcquireInterruptibly(int arg)/**     * Acquires in exclusive interruptible mode.     * @param arg the acquire argument     */    private void doAcquireInterruptibly(int arg)        throws InterruptedException {        final Node node = addWaiter(Node.EXCLUSIVE);        try {            for (;;) {                final Node p = node.predecessor();                if (p == head && tryAcquire(arg)) {                    setHead(node);                    p.next = null; // help GC                    return;                }                /*                acquireQueued代码:           if (shouldParkAfterFailedAcquire(p, node) &&                    parkAndCheckInterrupt())                    interrupted = true;*/                if (shouldParkAfterFailedAcquire(p, node) &&                    parkAndCheckInterrupt())                    break;            }        } catch (RuntimeException ex) {            cancelAcquire(node);            throw ex;        }        // Arrive here only if interrupted        // 取消获取锁尝试，将当前节点从等待队列中移除        cancelAcquire(node);        throw new InterruptedException();    }

在抛出异常之前，doAcquireInterruptibly还做了一件事情，cancelAcquire。cancelAcquire中有些细节值得玩味，参见代码中笔者注释。

AbstractQueuedSynchronizer.cancelAcquire(Node node)/**     * Cancels an ongoing attempt to acquire.     *     * @param node the node     */    private void cancelAcquire(Node node) {    // Ignore if node doesn't exist        if (node == null)        return;    node.thread = null;    // Skip cancelled predecessors    // 头节点一定不会是在等待状态，所以不会被cancel,所以这里一定能找到一个节点而不用担心null    Node pred = node.prev;    while (pred.waitStatus > 0)        node.prev = pred = pred.prev;    // Getting this before setting waitStatus ensures staleness    Node predNext = pred.next;    // Can use unconditional write instead of CAS here    node.waitStatus = Node.CANCELLED;    // If we are the tail, remove ourselves    if (node == tail && compareAndSetTail(node, pred)) {        compareAndSetNext(pred, predNext, null);    } else {        // If "active" predecessor found...        if (pred != head        && (pred.waitStatus == Node.SIGNAL            || compareAndSetWaitStatus(pred, 0, Node.SIGNAL))        && pred.thread != null) {        // If successor is active, set predecessor's next link        Node next = node.next;        if (next != null && next.waitStatus <= 0)            compareAndSetNext(pred, predNext, next);        } else {        /*这里如果不调用unparkSuccessor, 若在interrupted之后，执行到上面一句将waitStatus置CANCELLED之前，锁被释放，该线程被唤醒，则释放锁线程的unparkSuccessor不能起到预期作用，所以这里需要调用unparkSuccessor.即使此时持有锁的线程没有释放锁也不会有严重后果，被unpark的线程在获取锁失败后会继续park*/        unparkSuccessor(node);        }        node.next = node; // help GC    }    }