一、ReentrantLock使用

ReentrantLock是一种可重入锁，已经获得锁的线程可以继续获取锁也就是lock+1，但是同理加锁次数与释放锁次数必须相同才是正真的释放了锁。

public class ReentrantLockTest {

    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {

        // 运行线程A
        ThreadA threadA = new ThreadA("ReentrantLockThreadA");
        threadA.start();
        // 运行线程B
        ThreadB threadB = new ThreadB("ReentrantLockThreadB");
        threadB.start();

    }

    static class ThreadA extends Thread {

        public ThreadA(String name) {
            super(name);
        }

        public void run() {

            System.out.println("进入线程 " + Thread.currentThread().getName());
            // 加锁
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " 加锁1次");
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " 加锁2次");
            // 释放锁
            lock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放锁1次");
            lock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放锁2次");
        }
    }

    static class ThreadB extends Thread {

        public ThreadB(String name) {
            super(name);
        }

        public void run() {

            System.out.println("进入线程 " + Thread.currentThread().getName());
            // 加锁
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " 加锁1次");
            // 释放锁
            lock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放锁1次");
        }
    }
}

打印结果

进入线程 ReentrantLockThreadA
ReentrantLockThreadA 加锁1次
ReentrantLockThreadA 加锁2次
ReentrantLockThreadA 释放锁1次
ReentrantLockThreadA 释放锁2次
进入线程 ReentrantLockThreadB
ReentrantLockThreadB 加锁1次
ReentrantLockThreadB 释放锁1次

上述打印结果显示比较明显，先对A线程加锁两次后再释放锁两次，然后线程B在A释放锁后，继续获得锁，并执行结束。
那么如果将线程A第二次释放锁的代码删除掉，也就是这两行代码

            lock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放锁2次");

会发生什么？
执行结果为

进入线程 ReentrantLockThreadA
ReentrantLockThreadA 加锁1次
ReentrantLockThreadA 加锁2次
ReentrantLockThreadA 释放锁1次
进入线程 ReentrantLockThreadB

线程B永远处于等待状态，拿不到锁，因为线程A少释放了一次锁。

二、ReentrantLock源码解析

ReentrantLock实现了Lock接口

public class ReentrantLock implements Lock, java.io.Serializable {
    private final Sync sync;
    public void lock()
    // 发生中断会抛出InterruptedException
    public void lockInterruptibly()
    public boolean tryLock()
    public boolean tryLock(long timeout, TimeUnit unit)
    public void unlock()
    public Condition newCondition()
    // 获取加锁的次数
    public int getHoldCount()
    // 当前线程是否获得了锁
    public boolean isHeldByCurrentThread()
    // 是否已被加锁，可能是当前线程或者其它线程加的锁
    public boolean isLocked()
    // 公平锁会使用，判断队列中是否有线程等待获取锁
    public final boolean hasQueuedThreads()
    public final boolean hasQueuedThread(Thread thread)
    // 公平锁队列长度
    public final int getQueueLength()
    public boolean hasWaiters(Condition condition)
    public int getWaitQueueLength(Condition condition)
}

重点看sync以及加锁、释放锁和部分注释的方法。ReentrantLock内部实现包含了两种锁，非公平锁(默认)和公平锁，两种锁基于Sync实现。先看下Sync实现

    abstract static class Sync extends AbstractQueuedSynchronizer {

        abstract void lock();

        // 非公平获取锁的实现， 参数acquires表示几次加锁，一般为1
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            // 获取当前已加锁次数，状态0表示未加锁
            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;
        }

        // 释放锁
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            // 只有获得锁的线程才能释放锁
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                // 当释放锁次数和加锁次数一样时，返回true
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
}

基于Sync有两种实现非公平锁NonfairSync和公平锁FairSync，直接看下NonfairSync的实现

    static final class NonfairSync extends Sync {

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

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

lock方法获取锁的最终实现还是tryAcquire方法获得锁。
非公平锁NonfairSync与公平锁有什么区别呢？先看下非公平锁NonfairSync的实现

    static final class FairSync extends Sync {

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

唯一有区别的就是这一行代码

                if (!hasQueuedPredecessors() &&

也就是说，公平锁根据加锁的先后顺序将线程放到队列中，当锁被上一个线程释放后，会从队列中按照顺序，取线程给予锁权限。非公平锁就是完全看"天意"，大家不停try，谁也不确定什么时候能拿到锁。