ReentrantLock
AQS是同步器的基础，要先了解AQS的实现
使用实例：
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
lock.lock();
try {
while(条件判断表达式) {
condition.wait();
}
// 处理逻辑
} finally {
lock.unlock();
}
ReentrantLock可重入锁就是当前持有该锁的线程能够多次获取该锁，无需等待；
我们之前介绍过AQS，它是J.U.C包的基础，实现了同步器的主要功能。那么ReentrantLock是怎么利用AQS的？
这要从ReentrantLock的一个内部类Sync的父类说起，Sync的父类是AQS，Sync的两个实现类分别是NonfairSync和FairSync,由名字可以猜到，一个是用于实现公平锁、一个是用于实现非公平锁。
那么Sync为什么要被设计成内部类呢？这是文档里建议你使用的方法，子类应该是一个非public的内部类。为什么我想是因为安全，AQS里有很多方法，直接让ReentrantLock继承意味着拥有了操作权，容易误用，所以采用内部类实现的方法；
public void lock() {
sync.lock();
}
public void unlock() {
sync.release(1);
}
ReentrantLock的lock与unlock方法委托给了sync；
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
abstract void lock();
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;
}
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;
}
构造器：
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
非公平锁：
在上面的实例中，使用的就是非公平锁，啥叫非公平？就是插队，举个例子：A，B两个线程，B排在A后等待被唤醒，此时A执行完了同步状态清零，唤醒B，但在这是C抢了进来，B没有争过C，也就是B被C插了队，这是不公平的；
继承AQS的子类，要实现自己的tryRelease与tryAcquire；
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);
}
}
举例：A，B两个线程竞争，A成功同步状态会被设置成1，exclusiveOwnerThread（在AbstractOwnableSynchronizer中）；B失败。
B会调用acquire——>tryAcquire——>nonfairTryAcquire:在该方法中又会再一次判断下同步状态因为A可能执行完了，否则会检查当前线程是否是exclusiveOwnerThread中保存的线程，是则增加同步状态次数（这里是可重入的代码实现），都不是，则放入阻塞队列（逻辑在我的AQS文章中）
nonfairTryAcquire里实现了可重入的逻辑，与exclusiveOwnerThread保存的线程相等则允许进入，增加次数。
公平锁
之前说非公平是因为存在插队，而插队发生在AQS的acquireQueued方法的for循环中
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
之前的AQS里介绍过，当前线程release将同步状态归零，这是一处被插队的机会；当在等待队列中等待的线程被head唤醒，他会再一次进行判断，就是tryAcquire，在这里就有可能被竞争的线程抢先，即插队；所以要想实现公平锁就得对tryAcquire进行更改，怎么改？不是head的next节点就不能返回true
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
/**
* 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) {
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;
}
}
hasQueuedPredecessors就实现了这个逻辑，下一个线程首先必须是head的next指向的节点才行。
重入逻辑
在非公平锁的nonfairTryAcquire里与公平锁FairSync 的tryAcquire里都有如下重入逻辑
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
