ReentrantLock重入锁

1 ReentrantLock(重入锁)的概述

1.1 ReentrantLock的定义

• 支持重进入的锁，即该锁能够支持一个线程对资源的重复加锁。
• 支持获取锁时的公平和非公平性选择。

1.2 synchronized关键字 & ReentrantLock (支持重进入的区别)

• synchronized关键字隐式的支持重进入，比如一个synchronized修饰的递归方法，在方法执行时，执行线程在获取了锁之后仍能连续多次地获得该锁。
• ReentrantLock虽然没能像synchronized关键字一样支持隐式的重进入，但是在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。

2 ReentrantLock源代码

2.1 ReentrantLock

public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    private final Sync sync;

	//Sync
	abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
	       
	    //lock()
        abstract void lock();
		
		//nonfairTryAcquire()
		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;
		}
		
		//tryRelease()
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        protected final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }
        
        //....
    }

	//非公平锁
	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);
	        }
	}
	
	//公平锁
	static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

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

        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;
        }
    }

	//ReentrantLock的构造方法
	public ReentrantLock() {
        sync = new NonfairSync();
    }
	public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    
	//加锁
	public void lock() {
        sync.lock();
    }
    //解锁
    public void unlock() {
        sync.release(1);
    }