Java源码阅读之ReentrantLock - lockInterruptibly和tryLock方法

阅读优秀的源码是提升编程技巧的重要手段之一。
如有不对的地方，欢迎指正
转载请注明出处http://www.imooc.com/u/125243。

碎碎念

上一篇博客阅读了Java的ReentrantLock的lock和unlock，这篇分析另外三个方法lockInterruptibly、tryLock()和tryLock(long time, TimeUnit unit) throws InterruptedException;

嗯，闲话少说，开工。

lockInterruptibly

顾名思义，这是一个可中断的获取锁方法。

方法的描述如下：
请求锁，除非当前线程被中断。

如果没有其他线程持有锁，则当前线程获取到锁，并为锁计数加1，并且立即返回。
如果当前线程已经持有锁，则为锁计数加1，并立即返回。
如果其他线程持有锁，则当前线程将处于不可用状态以达到于线程调度目的，并且休眠直到下面两个事件中的一个发生：
①、当前线程获取到锁
②、其他线程中断当前线程

如果当前线程获取到锁，则将锁计数设置为1。
如果当前线程在方法条目上设置了中断状态或者在请求锁的时候被中断，将抛出中断异常。

阅读 Continue

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

从源码可以看出，实现还是依赖于内部类Sync，acquireInterruptibly方法是Sync的父类AbstractQueuedSynchronizer-AQS提供的，我们主要还是以NonFairSync实现为主进行阅读。

继续，可以看到方法内部有两个if判断，第一个是判断线程的中断标识，如果为true，则抛出中断异常。

另外一个if，则是去尝试获取锁，并判断获取结果，如果获取失败，则执行doAcquireInterruptibly

①
public final void acquireInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}

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

这里的tryAcquire方法目的是尝试获取锁，与上一篇博客里提到的是一致的，这里不再赘述，直接看tryAcquire失败后执行的doAcquireInterruptibly

private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
    //将当前线程添加等CLH等待队列
    final Node node = addWaiter(Node.EXCLUSIVE);
    //初始化失败标志
    boolean failed = true;
    try {
        //利用循环/自旋来请求锁
        for (;;) {
            //获取前置节点
            final Node p = node.predecessor();
            //如果前置节点为首节点，并且当前线程能够成功获取锁
            if (p == head && tryAcquire(arg)) {
                //将当前节点设置为首节点
                setHead(node);
                p.next = null; // help GC 前首节点出队，帮助GC 
                failed = false;
                return;
            }
            //判断是否可以阻塞线程并做相应操作
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                //抛出中断异常
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

基本上可以看出，跟之前分析的acquireQueued方法是相似的。将当前线程加入CLH的等待队列后，进行循环/自旋获取锁，未获取成功则判断是否可以阻塞并做相关操作。

具体的shouldParkAfterFailedAcquire和parkAndCheckInterrupt请参照上一篇，此处不再赘述。

到这里lockInterruptibly告一段落。

tryLock()

该方法也是获取锁的一种，与lock和lockInterruptible不同的是，tryLock()方法会立即返回结果，如果锁可用并且当前线程能够成功获取的话，直接返回true，否则返回false。

下面具体看下ReentrantLock是怎么实现的

public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}

还是Sync提供实现

final boolean nonfairTryAcquire(int acquires) {
    //获取当前线程
    final Thread current = Thread.currentThread();
    //获取锁状态
    int c = getState();
    //如果锁未被其他线程持有
    if (c == 0) {
        //CAS操作设置锁状态
        if (compareAndSetState(0, acquires)) {
            //成功后设置当前线程未锁独占线程，并返回true
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //如果锁已经线程持有，判断是否是当前线程持有，如果是，则允许重入
    else if (current == getExclusiveOwnerThread()) {
        //增加锁持有计数
        int nextc = c + acquires;
        //判断重入次数是否溢出
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        //设置锁持有计数
        setState(nextc);
        //返回true
        return true;
    }
    //如果锁被其他线程持有，返回false
    return false;
}

tryLcok是立即返回结果的获取锁方式，相比之前提到的几种自旋方式，它只进行一次获取锁的尝试，成功则返回true，失败则返回false，如果场景要求只进行一次尝试，则可以采用此方法。

tryLock(long time, TimeUnit unit)

为了标题简洁，未将异常声明加上，完整的方法定义是boolean tryLock(long time, TimeUnit unit) throws InterruptedException;该方法可能抛出中断异常。

方法描述如下：
在给定的等待时间内并且线程没有被中断以及锁可用的情况下，去获取锁。
如果锁可用，方法会直接返回。
如果锁不可用，则当前线程将会处于不可用状态以达到线程调度目的，并且休眠直到下面三个事件中的一个发生：
①、当前线程获取到锁
②、其他线程中断当前线程
③、指定的等待时间已过
假如当前线程：
在该方法的条目上设置其中断状态或在获取锁时中断，并且支持锁获取中断时，将抛出中断异常，当前线程中断状态会被清除。
假如给定的等待时间已过，将会返回false。

下面具体阅读源码实现,方法的入参指定了等待时间，和时间的单位，有NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS...等单位。

public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

方法的内部调用了Sync的tryAcquireNanos，继续往下

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    //判断中断状态并决定是否抛出中断异常
    if (Thread.interrupted())
        throw new InterruptedException();
    //尝试获取锁，如果成功则返回true，失败则调用doAcquireNanos进行等待
    return tryAcquire(arg) ||
        doAcquireNanos(arg, nanosTimeout);
}

tryAcqure和之前分析的是同一个方法，不再赘述。
接下来是doAcquireNanos方法

private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
    //如果给定的时间值小于等于0，则直接返回false
    if (nanosTimeout <= 0L)
        return false;
    //根据给定参数计算截止时间
    final long deadline = System.nanoTime() + nanosTimeout;
    //将当前线程添加到CLH等待队列
    final Node node = addWaiter(Node.EXCLUSIVE);
    //初始失败标志
    boolean failed = true;
    try {
        //在给定时间内循环/自旋尝试获取锁
        for (;;) {
            //取出前置节点
            final Node p = node.predecessor();
            //如果前置节点为首节点，并且当前线程能够成功获取锁
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC 前首节点出队，帮助GC
                failed = false;
                return true;
            }
            //判断是否等待超时，如果超时，则返回false
            nanosTimeout = deadline - System.nanoTime();
            if (nanosTimeout <= 0L)
                return false;
            //这里判断是否可以阻塞线程并做相应操作，跟之前分析的几个方法不一样的是，这里的阻塞多了一个判断，并且是在有限时间内阻塞，类似于sleep
            if (shouldParkAfterFailedAcquire(p, node) &&
                nanosTimeout > spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            //判断中断状态，并决定是否抛出异常
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

从上面我们可以看出doAcquireNanos跟doAcquireInterruptibly以及上一篇博客提到的acquireQueued的都有相似点，都是有自旋等待，以及阻塞判断和阻塞操作，不同的是，doAcquireNanos的阻塞是有时间限制的，所以能在给定的时间内，返回获取锁的操作结果。

总结

lockInterruptibly是可中断的获取锁方式。

tryLock()是立即返回获取结果的获取锁方式。

tryLock(long time, TimeUnit unit)是在给定时间内，尝试获取锁的方式。

好了，告一段落。

源码也看了不少，之前写的解析也都没有整理到博客，现在终于是能抽出点时间动动手了。

如果对你有哪怕一丢丢帮助，不妨给个赞呗，溜了溜了。