ReentrantLock
上一节分析了AbstractQueuedSynchronizer同步器的相关实现，现在在具体看下同步器的具体实现，也是大家常用的锁ReentrantLock，ReentrantLock重入锁，是指一个线程能够重复加锁。首先查看获取锁的lock()方法
Sync
ReentrantLock内部真正实现加锁的类是非公平锁NonfairSync和公平锁FairSync，都继承于Sync
继承关系类图
下面看下Sync类，Sync类里面含有抽象方法lock()，lock方法被子类实现来实现加锁的逻辑，因为Sync继承于AbstractQueuedSynchronizer，所以必须要实现tryAcquire()方法，Sync没有实现，需要子类去实现，Sync实现了nonfairTryAcquire()非公平加锁的方法
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//如果同步状态为0 ，表示当前没有线程获取到锁
if (c == 0) {
//通过CAS方式，尝试获取同步状态
if (compareAndSetState(0, acquires)) {
//获取成功，则设置当前线程占有锁
setExclusiveOwnerThread(current);
return true;
}
}
//需要考虑重入特性，如果当前线程已经获取了同步状态
else if (current == getExclusiveOwnerThread()) {
// 更新当前同步状态，
int nextc = c + acquires;
// 如果同步状态的值大于Integer.MAX_VALUE时，抛出异常
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 获取成功
setState(nextc);
return true;
}
// 获取失败
return false;
}
- 如果当前同步状态值为0，表示当前没有线程获取锁，那么通过CAS方式尝试获取同步状态，成功也加锁成功
- 如果已经获取同步状态的线程就是当前线程，考虑到重入性，那么会更新同步状态，获取同步状态成功
- 如果不满足上面两种情况，那么获取锁失败，返回false
下面再看下tryRelease()释放同步状态的方法
protected final boolean tryRelease(int releases) {
// 减去获取锁时加到同步状态上的值
int c = getState() - releases;
// 如果当前获取到同步状态线程的不是当前线程，则抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
// 是否释放了同步状态，因为重入的特性，只有当state == 0 时，才表明释放当前状态
boolean free = false;
if (c == 0) {
free = true;
// 设置当前获取同步状态的线程为null
setExclusiveOwnerThread(null);
}
// 更新同步状态
setState(c);
// 返回释放完全释放同步状态
return free;
}
- 得到释放当前锁后，同步状态的最新值
- 如果当前获取到同步状态线程的不是当前线程，则抛出异常
- 如果state更新为0 ，那么就表示已经没有线程持有同步状态，否则表示还有线程拥有同步状态
NonfairSync
NonfairSync非公平锁与FairSync公平锁，这里会涉及到锁的公平性问题如果在绝对时间上，先对锁进行获取的请求一定先被满足，那么这个锁是公平的，反之，是不公平的。公平的获取锁，也就是等待时间最长的线程最优先获取锁，也可以说锁获取是顺序的。ReentrantLock提供了一个构造函数，能够控制锁是否是公平的。
看下NonfairSync的lock()
final void lock() {
// 因为是非公平锁，设置直接尝试获取同步同步状态 成功则表示加锁成功
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
// 设置同步状态失败，则尝试acquire()方法
else
acquire(1);
}
// 实现了AbstractQueuedSynchronizer的tryAcquire()，直接调用Sync的nonfairTryAcquire()
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
FairSync
公平锁
final void lock() {
// 与NonfairSync不同，没有通过CAS方式获取锁，直接调用acquire()
acquire(1);
}
// 实现同步器的方法，
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 如果没有前驱节点，才会尝试通过CAS获取同步状态
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;
}
- tryAcquire()与nonfairTryAcquire() 唯一的不同之处就在与!hasQueuedPredecessors() 在尝试通过CAS获取同步状态时，会先判断当前节点是否有前驱节点，如果没有前驱节点，则表明当前节点时头节点后的第一个节点，所以此时可以尝试获取同步状态，否则表明当前节点不是头节点的后一个节点，则为了保证公平性，不回去尝试获取同步状态
ReentrantLock
下面再看下ReentrantLock类
private final Sync sync;// 同步器
// 默认构造函数，sync时非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
// 也可以由用户选择sync是公平锁还是非公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
public void lock() {
// 调用sync的方法
sync.lock();
}
public boolean tryLock() {
// 直接调用非公平性尝试加锁
return sync.nonfairTryAcquire(1);
}
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
//调用同步器的尝试加锁及超时设置
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
//释放锁
public void unlock() {
sync.release(1);
}
通过上面的分析，就会对ReentrantLock的加锁和释放锁的操作就会很清楚了
