ReentrantLock中lock/trylock/lockInterruptibly方法的区别及源码解析

看了几篇关于这三者区别的文章，但都说的不够具体，自己去读了下源码，大概是清楚了三者的功能，不想了解源码的可以跳到最后看总结。

首先，ReentrantLock类中使用了大量的CAS操作，也就是CompareAndSwap原子操作，依靠硬件保证互斥与同步，然后说下interrupt()方法。每个线程都有一个interrupt标志。当线程在阻塞状态时，如sleep、wait、await（park）、join，此时如果对该进程调用interrupt()方法，该线程会被唤醒、interrupt标志被修改，并抛出InterruptedException异常（一旦捕捉到异常，立刻重置interrupt标志），因此上述的那些方法被要求为必须捕捉异常；当线程在运行中并未进入任何阻塞状态时，则interrupt()操作不会打断线程执行，只会修改该线程interrupt标志，此时可以通过Thread.interrupted()/实例.isInterrupted()查看并作出处理(前者会重置该标志位)，通常使用while循环来检查。

一、 lock()方法

使用lock()获取锁，若CAS替换state成功，则直接标记本线程获取到了锁，然后返回。若获取失败，这时先将线程阻塞放入等待队列，然后跑一个for循环（如下代码），parkAndCheckInterrupt方法调用LockSupport.park()使线程进入阻塞状态，当它被被唤醒（前一个节点unpark唤醒or外部interrupt唤醒）时会调用tryAcquire继续尝试竞争锁。如果此时用CAS获取到了锁那么就返回，如果没获取到那么再次放入等待队列，如此循环。其间就算外部调用了interrupt()，循环也会继续走下去。一直到当前线程获取到了这个锁，此时才处理interrupt标志，若有，则执行自我调用 Thread.currentThread().interrupt()，结果如何取决于外层的处理。

    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;
                    return interrupted; //获取成功返回interrupted标志
               }
                 // 只修改标志位，不做其他处理
                 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) 
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

其中parkAndCheckInterrupt()调用了LockSupport.park()，该方法使用Unsafe类将进程阻塞并放入等待队列，等待唤醒，和await()有点类似。

可以看到循环中检测到了interrupt标记，但是仅做 interrupted = true 操作，直到获取到了锁，才return interrupted，然后处理如下

   public final void acquire(int arg) {
        if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt(); // 执行Thread.currentThread().interrupt()
    }

 

二、 lockInterruptibly()方法

和lock()相比，lockInterruptibly()只有略微的修改，for循环过程中，如果检测到interrupt标志为true，则立刻抛出InterruptedException异常，这时程序便通过异常直接返回到最外层了，由外层继续处理，因此使用lockInterruptibly()时必须捕捉异常。lockInterruptibly()最终执行的方法如下:

    private void doAcquireInterruptibly(int arg)
        throws InterruptedException {
        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
                    failed = false;
                    return; //获取成功返回
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException(); //直接抛出异常
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

 

三、 tryLock()方法

使用tryLock()尝试获取一次锁，若获取成功，标记下是该线程获取到了锁，然后返回true；若获取失败，此时直接返回false，之后的操作取决于外层，代码如下：

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    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);
                return true;
            }
            return false;
        }

 

else if 中的情况属于锁重入情况，即外层函数已经获取到这个锁了，内部的函数又再次对其进行获取，那么对计数器加一，不再循环加锁。

四、tryLock(long timeout, TimeUnit unit) 方法

还有一种情况，即使用tryLock(long timeout, TimeUnit unit)获取锁，此时有点像lockInterruptibly()的升级版，在获取锁失败后的循环中，它被放入等待队列并使用 LockSupport.parkNanos(this, nanosTimeout) 阻塞进程，同时timeout扣减每次循环消耗的时间，当timeout用尽时如果依然没有获取到锁，那么就返回false。对于循环期间收到的interrupt()的处理，这儿和lockInterruptibly()一样，一旦检测到，那么直接抛出异常。代码如下：

    private boolean doAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
        long lastTime = System.nanoTime();
        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
                    failed = false;
                    return true; //获取成功返回
                }
                if (nanosTimeout <= 0)
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout); //带timeout的阻塞
                long now = System.nanoTime();
                nanosTimeout -= now - lastTime;
                lastTime = now; // 更新timeout
                if (Thread.interrupted())
                    throw new InterruptedException(); //直接抛出异常
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }

 

总结

1. lock()  阻塞式地获取锁，只有在获取到锁后才处理interrupt信息
2. lockInterruptibly() 阻塞式地获取锁，立即处理interrupt信息，并抛出异常
3. tryLock()  尝试获取一次锁，不管成功失败，都立即返回true、false
4. tryLock(long timeout, TimeUnit unit)在timeout时间内阻塞式地获取锁，成功返回true，超时返回false，同时立即处理interrupt信息，并抛出异常