ReentrantLock源码浅析

---

一、前言

  在此前《ReentrantLock基本介绍》这篇博客中已经介绍了ReentrantLock的基本使用，那在本篇博客中将会简要介绍下其内部的主要源码。

前提：对AbstractQueuedSynchronizer（简称AQS）有了解，不清楚的可以先去看看《AbstractQueuedSynchronizer源码——基本认识》

二、源码介绍

1、基本构造

  在上面两篇博客中都有提到过ReentrantLock，ReentrantLock的功能实现依赖于AQS，下面只是截取的部分源码，详细的在后面说面。

public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    // 下面的内部类，上锁、解锁最终是通过该对象操作
    private final Sync sync;

    /**
     * Sync继承于AbstractQueuedSynchronizer 
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // 具体内容省略...
    }

    /**
     * 非公平锁，继承了上面的Sync
     */
    static final class NonfairSync extends Sync { 
    	// 具体内容省略...
    }

    /**
     * 公平锁，继承了上面的Sync
     */
    static final class FairSync extends Sync { 
    	// 具体内容省略...
    }

    /**
     * 默认构造，可以看到是new的NonfairSync对象
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * 带参构造，传true就会new FairSync对象 
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    
    // 加锁
    public void lock() {
        sync.lock();
    }

	// 解锁
    public void unlock() {
        sync.release(1);
    }
	// 其他省略...
}

2、加锁与解锁

2.1、加锁

  从上面代码可以看出ReentrantLock的加锁是调用了Sync中的lock方法，但是Sync中lock也是抽象方法，具体实现就得看其子类FairSync、NonfairSync。

    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
		// 抽象方法
        abstract void lock();

        final boolean nonfairTryAcquire(int acquires) {
            ...
        }

        protected final boolean tryRelease(int releases) {
           ...
        }
    }

2.1.1、公平锁

  公平锁对应的FairSync类，可以看到在FairSync的lock方法中调用了AQS中的acquire方法，如果是看了AQS源码的就会知道，该方法是独占模式下获取资源的方法，这里就体现出了ReentrantLock是属于独占锁。

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }
		//...
    }

再把AQS的方法源码贴出来，可以看到此方法里面首先会执行tryAcquire方法，在AQS中tryAcquire方法都是有AQS的子类自行设计实现（《AbstractQueuedSynchronizer源码——基本认识》有介绍），所以这里将会执行FairSync 中的tryAcquire方法。

	// #AbstractQueuedSynchronizer
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

FairSync 中的tryAcquire方法：

    static final class FairSync extends Sync {
        //...
        
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            // 获取state
            int c = getState();
            // 为0说明资源已被释放，可以去尝试获取
            if (c == 0) {
            	// hasQueuedPredecessors这个方法就是公平锁的实现
            	// 该方法做的事请就是在当前线程想要去获取资源前，判断在AQS的等待队列中他前面是否有正常等待的线程，
            	//有返回true，没有返回false
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) { // CAS设置state值为1
                    setExclusiveOwnerThread(current); // 若签到资源后，设置当前线程为资源拥有者
                    return true;
                }
            }
            // 倘若state不为0，如果当前线程正好是资源拥有者（就是当前线程没释放锁，然后有来获取锁来了）
            else if (current == getExclusiveOwnerThread()) {
            	// state值+1，这里就是体现了ReentrantLock的可重入性
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

上面代码中hasQueuedPredecessors()实现了公平锁，也就是说在线程获取资源之前先要检查等待队列，如果你前面还有人，那么你抢到了也没用（!hasQueuedPredecessors()等于false，不会进入if)，在else if中则体现了可重入性，有用资源的时候再来获取资源，那么state值就会增加1。

2.1.2、非公平锁

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


        final void lock() {
        	// 尝试快速方式获取资源，state=0时CAS设置
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else // 不为0则acquire方法获取资源
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
        	// 尝试获取锁时这里调用的是Sync中的nonfairTryAcquire方法
            return nonfairTryAcquire(acquires);
        }
    }

	// #ReentrantLock.Sync
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
        	// 这里可以对比公平锁中，少了hasQueuedPredecessors方法去做判断，谁抢到就算谁的
            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;
      }

在非公平锁中上面代码可以看到，在获取锁时有个取巧的操作，就是通过CAS的特性如果state正好为0来快速判断，然后在tryAcquire中的区别就是少了hasQueuedPredecessors方法去做判断。

2.2、解锁

  解锁对应unlock方法。

    public void unlock() {
    	// 调用了AQS中的release
        sync.release(1);
    }

贴出AbstractQueuedSynchronizer中的release，方法中的释放方法tryRelease则是在ReentrantLock中的Sync实现。

    // #AbstractQueuedSynchronizer 
    public final boolean release(int arg) {
    	// 这里
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

贴出ReentrantLock中的tryRelease。

	// #ReentrantLock.Sync
	protected final boolean tryRelease(int releases) {
		// 获取state值并减去releases（releases=1）
	    int c = getState() - releases;
	    if (Thread.currentThread() != getExclusiveOwnerThread())
	        throw new IllegalMonitorStateException();
	    boolean free = false; // 资源是否空闲，默认false
	    if (c == 0) {
	    	// 如果state-1=0，那么就表示成功释放掉锁了，后面其他线程可以去获取资源了
	        free = true; // 置为true
	        // 资源拥有者置为null
	        setExclusiveOwnerThread(null);
	    }
	    // 否者将state重新赋值新的值，返回的free也将是false
	    // 所以之前提到过，ReentrantLock加了几次锁就得解锁几次，要不然锁一致将会是被占用状态
	    setState(c);
	    return free;
	}

总的来说解锁其实就是将state的值置减1，当为0后这表示解锁成功。

三、小结

  上面就是对ReentrantLock的源码基本介绍，大前提是得知道AQS的流程，了解后其实ReentrantLock的源码就不是什么问题了，再过来看也就是看看可重入性、公平、非公平具体是在哪体现出来的了。