ReentrantLock类注释
1、可重入互斥锁，意思是表示该锁能够支持一个线程对资源的重复加锁，该锁还支持获取锁的公平和非公平性选择。synchronized关键字隐式的支持重进入。
2、可以通过isHeldByCurrentThread判断当前线程是否拿到锁。
3、构造器接收fairness参数，fairness=true表示公平锁反之是非公平锁。
4、tryLock() 无参方法没有遵循公平性，是非公平的。
5、公平锁的吞吐量没有非公平锁高，需要不断的进行线程之间的切换
ReentrantLock类结构
public class ReentrantLock implements Lock, java.io.Serializable
Lock所定义的方法。
- lock（）：获取锁，调用该方法的线程会获取锁。
- unlock(): 释放锁
- tryLock(): 尝试非阻塞的获取锁，获取成功返回true，失败返回false。
- tryLock(long,TimeUtil): 超时获取锁，有三种情况：当前线程在超时时间内获得了锁，当前线程在超时时间内被中断，超时时间结束，返回false。
- lockInterruptedException(): 可中断的获取锁，所在获取过程中可以中断当前线程。
公平锁与非公平锁
简言之，如果在绝对的时间上，先对锁发起请求的那个线程会先获取锁，遵循FIFO原则，也就是等待时间最长的那个线程最先获取锁。
公平锁和非公平锁只是相对于获取锁的时候而言。
如果一个锁是公平的，那么锁获取的顺序符合时间顺序。当一个线程获取了同步状态就可以认为获取到了锁，刚释放锁的线程下次再获取锁的概率非常大，使其他线程在同步队列中等待，因此非公平锁的线程切换次数很少，这是相对公平锁而言，所以吞吐量上，非公平锁更有优势，所以默认情况下，ReentrantLock的构造就是非公平锁。
互斥锁
互斥锁：同一时刻下，只有一个线程可以拿到锁，其他线程只能在同步队列中等待，只有拿到锁的线程释放锁，其他线程才能去争抢；
构造方法
public ReentrantLock() {
// 默认是非公平锁
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
从构造器中可以看出，公平锁是依靠 FairSync 实现的，非公平锁是依靠 NonfairSync 实现的。
Sync同步器
Sync继承了AQS，lock方法留给FairSync和NonFairSync两个子类实现，他实现了AQS的tryRelease方法和isHeldExclusively方法。
abstract static class Sync extends AbstractQueuedSynchronizer{
// 尝试释放锁
protected final boolean tryRelease(int releases) {
// releases一般是1，当前线程的同步状态-同步值
int c = getState() - releases;
// 当前线程没有持有锁，抛异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 当前线程持有的锁都释放了
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
// c!=0代表是重入锁，锁没有释放完毕，前面已经用state-releases
setState(c);
return free; // return false，尝试释放锁失败
}
protected final boolean isHeldExclusively() {
// While we must in general read state before owner,
// we don't need to do so to check if current thread is owner
return getExclusiveOwnerThread() == Thread.currentThread();
}
}
加锁
先来看FairSync公平锁的lock方法和tryAcquire
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
// 尝试加锁，acquire方法是AQS的获取锁的方法，如果尝试获取锁失败，会进入同步队列中等待
final void lock() {
acquire(1);
}
/**
AQS的acquire
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
**/
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// hasQueuedPredecessors 是实现公平的关键
// 会判断当前线程是不是属于同步队列的头节点的下一个节点(头节点是释放锁的节点)
// 如果是(返回false)，符合先进先出的原则，可以获得锁
// 如果不是(返回true)，则继续等待
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 如果获取锁的线程再次请求锁，将通天阁不状态值增加并返回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;
}
}
再来看NonFairSync非公平锁的加锁和尝试获取锁
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
// 通过判断当前线程是否获取锁的线程来决定获取操作是否成功，如果同步状态值成功修改，那就代表当前线程获取到了锁
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
// 调用的是父类Sync的尝试获取锁的方法
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
释放锁
unlock 释放锁的方法，底层调用的是 Sync 同步器的 release 方法，release 是 AQS 的方法，分成两步：
- 尝试释放锁，如果释放失败，直接返回 false；
- 释放成功，从同步队列的头节点的下一个节点开始唤醒，让其去竞争锁。
第一步就是我们上文中 Sync 的 tryRelease 方法（4.1），第二步 AQS 已经实现了。
释放锁通过LockSupport.unpark(s.thread);
unLock 的源码如下：
// 释放锁
public void unlock() {
sync.release(1);
}