Java并发——重入锁ReentrantLock的实现原理及源码解析

1、什么是可重入锁？

可重入锁就是对于已经获得锁的线程，可以重复的多次的获得该锁。

而不可重入的锁在线程获得该锁后，该线程如果再次请求获得该锁，就会在调用tryAquires（）的时候返回false，从而阻塞自己。

2、可重入锁的实现原理？

要实现可重入锁的关键有两个，一个怎么识别当前请求锁的线程是不是已经获取锁的线程，另一个因为在一个线程重复的获取了n次锁以后，必须要释放n次锁才能完全释放锁，这怎么实现？

对于第一个问题，因为可重入锁是独占锁，所以只要比较当前线程是不是独占锁的线程，如果是则可以再次加锁，如果不是则返回false。

对于第二个问题，需要一个与锁关联的计数器，来对加锁的重数进行计数，每次获得锁都应该让计数器自增，而每次释放锁都应该让计数器自减，当计数器为0时，表示锁已经成功释放。

源码分析：

那么我们来看看源码：

public class ReentrantLock implements Lock, java.io.Serializable 

▶从继承关系上，可见ReentrantLock是实现了Lock接口，因此Lock接口的功能ReentrantLock也有Lock接口的可中断等待锁的线程，可以实现Condition等功能。

 private final Sync sync;
 abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
        abstract void lock();
        //重写nonFairAquire
         final boolean nonfairTryAcquire(int acquires) {
            //省略此处，在公平锁和非公平锁的实现中会讲到
        }
        //重写tryRelease
        protected final boolean tryRelease(int releases) {
            //省略此处
        }

从实现上可以看出，ReentrantLock是通过组合自定义同步器来实现锁的获取与释放，在ReentrantLock自定义了内部类sync，内部类sync继承了AbstractQueuedSynchronizor，并重写了nonfairTryAquire（）和tryRelease（）方法来获得锁和释放锁。

▶然后再看ReentrantLock的构造方法：

public ReentrantLock() {
        sync = new NonfairSync();
    }

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

可以看出，ReentrantLock默认实现非公平锁，如果传入表示公平的boolean变量fair，那么fair为true的时候，实现公平锁，fair为false的时候，实现非公平锁。而在ReentrantLock中实现公平锁和非公平锁都是通过实现一个静态内部类来实现了，该静态内部类继承了sync静态内部类。源码如下所示：

公平锁静态内部类

       protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

因为在sync内部类中没有重写公平锁的获取锁的方法，因此在公平锁的内部类中重写tryAquire（）方法，实现公平锁的获取。

通过tryAquire（）方法我们可以看出ReentrantLock的实现流程：首先获取锁的同步状态值，这个值是被volatile修饰的，这样可以保证这个值在多线程之间是可见的，如果锁没有被占用（c==0）那么让队列头的线程来获取锁，如果锁已经被占用，因为ReentrantLock是排他锁，因此可以把当前线程和独占的线程比较，如果当先线程就是独占锁的线程，那么可以获取锁，如果不是，则获取锁失败。

非公平锁静态内部类

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

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

因为在sync内部类中已经重写了nonFairAquire（）方法，因此直接调用nonFairAquire（）方法即可。

此外因为在sync内部类中已经重写了tryRelease（）方法，因此在这两个子类中都没有重写这个方法，需要的时候直接调用即可。

3、细节：

①synchronized关键字也是一种可重入锁，比如synchronized修饰的递归方法，在方法执行时，执行的线程在获得了锁以后仍然能够多次的获得锁，而不会因为锁之前已经被占有被阻塞线程本身。

②重入锁与synchronized的区别：

○性能上：

    ▶重入锁是显式的重入，而synchronized是隐式的重入。也就是说重入锁是用户自己添加和释放，由JDK实现，而 synchronized由操作系统来添加和释放锁，由JVM实现。因此便利性是synchronized优于重入锁。

     ▶锁的细粒度和灵活度：重入锁优于synchronized

     ▶synchronized在优化前，性能远不如重入锁，但是在synchronized引入偏向锁后、轻量级锁（自旋锁）后，二者的性能区别就不大了，在两者都可用的情况下，官方甚至建议使用synchronized。

○功能上：

    ▶因为重入锁实现了lock接口，因此提供了Condition类，可以实现分组唤醒需要唤醒的线程，而不是像synchronized一样要么随机唤醒，要么全部唤醒。

    ▶重入锁可以实现公平锁，但是默认的是实现非公平锁；而synchronized只能实现非公平锁；（关于公平锁与非公平锁，参见：点击打开链接）

     ▶重入锁提供了一种能够终端等待锁的线程，通过lock.lockInterruptibly( )实现。