JDK源码之ReentrantLock
1.定义
ReentrantLock是一种可重入锁，允许一个线程对同一个资源重复加锁，如果说是当一个线程调用一个锁的lock()方法，然后再次调用锁的lock()方法，当锁不支持可重入时，该线程会被自己所阻塞。该锁还能支持公平锁和非公平锁的选择，公平的意思就是将锁分配给等待锁时间最长的线程，这样可以避免饥饿情况的发生，但是造成线程大量的上下文切换，影响吞吐量。
从ReentrantLock的类定义来看，该锁实现了Lock和Serializable接口。
public class ReentrantLock implements Lock, java.io.Serializable
2.ReentrantLock的具体实现
ReentrantLock通过将继承AQS的子类sync作为类成员变量来实现锁，sync实现AQS的抽象方法来管理同步状态。
（1）Sync静态内部类
//AQS的子类。
private final Sync sync;
//Sync也是一个抽象类，因为锁有非公平和公平的区别。
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
//非公平和公平锁的lock()方法有不同的实现。
abstract void lock();
//tryLock()在子类中实现，该方法是非公平的独占式获取同步状态。
//该方法首先判断同步状态是否被获取，如果没有，CAS获取同步状态并将锁的拥有者设为当前线程，如果有，判断获取锁的线程是否是当前线程，如果是，将同步值进行累加。
//成功获取锁的线程，再次获取锁，只是增加了同步值。
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;
}
//获取了多少次锁，同样也要释放多少次锁。
//当同步值不为0时，还是当前线程占有锁。
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();
}
//得到锁的占有者
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
//获取锁的次数
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
//锁是否被获取
final boolean isLocked() {
return getState() != 0;
}
//反序列化操作
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
（2）NonfairSync和FairSync
ReentrantLock是支持公平锁和非公平锁的，而公平锁和非公平锁的具体实现是依靠AQS的抽象子类Sync的不同子类实现（NonfairSync和FairSync）。
//非公平锁的实现
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
//非公平锁加锁，acquire调用tryAcquire,tryAcquire调用nonfairTryAcquire
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);
}
//lock()调用acquire(),acquire()调用tryAcquire(),公平锁和非公平锁的tryAcquire()的实现唯一不同
//就是加入了hasQueuesPredecessors(),通过判断当前节点是否有前驱节点，如果有则当前节点不是等待时间最长的线程
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;
}
}
公平锁和非公平锁的主要在于两个地方：
1.获取锁lock()方法的不同：非公平锁会直接进行一次CAS，如果CAS成功，就直接获取锁了。
2.tryAcquire()方法实现的不同：当同步状态此时被释放的时候，state等于0，并没有任何线程占有锁，如果是公平锁，会判断队列中是否有线程等待获取锁，如果有的话，直接将自己构造成一个节点加入同步队列，但是非公平锁会直接CAS设置状态，不考虑同步队列中是否有其他线程等待获取锁。如果获取同步状态失败，会将自己构造成一个节点加入同步队列中，加入同步队列之后，等待前驱节点释放同步状态，唤醒自己，这后面的步骤公平锁和非公平锁是一样的。
3.ReentrantLock的主要方法
//构造函数默认是非公平锁
public ReentrantLock() { sync = new NonfairSync(); } //可选择实现公平锁 public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); } //获取锁 public void lock() { sync.lock(); } //可中断式的获取锁 public void lockInterruptibly() throws InterruptedException { sync.acquireInterruptibly(1); } //尝试非阻塞的获取锁，调用方法之后立马返回，能获取返回true,不能获取返回false public boolean tryLock() { return sync.nonfairTryAcquire(1); } //释放锁 public void unlock() { sync.release(1); } //获取等待通知组件，该组件和当前锁绑定 public Condition newCondition() { return sync.newCondition(); } //锁被获取的次数 public int getHoldCount() { return sync.getHoldCount(); } //锁是否被当前线程所占有 public boolean isHeldByCurrentThread() { return sync.isHeldExclusively(); } //锁是否已经被获取 public boolean isLocked() { return sync.isLocked(); } //是否是公平锁 public final boolean isFair() { return sync instanceof FairSync; } //获取锁的所有者 protected Thread getOwner() { return sync.getOwner(); } //是否有线程等待该锁 public final boolean hasQueuedThreads() { return sync.hasQueuedThreads(); } //查询给定线程是否在等待该锁 public final boolean hasQueuedThread(Thread thread) { return sync.isQueued(thread); } //查询等待锁的线程数 public final int getQueueLength() { return sync.getQueueLength(); } //返回等待锁的线程集合 protected Collection<Thread> getQueuedThreads() { return sync.getQueuedThreads(); }
4.ReentrantLock总结
聚合关系总结:
（1）ReentrantLock实现了Lock,Serializable接口
（2）ReentrantLock.Sync(内部类)继承了AQS
（3）ReentrantLock.NonfairSync和ReentrantLock.FairSync继承了ReentrantLock.Sync
（4）ReentrantLock持有ReentrantLock.Sync对象(实现锁功能)
性质:
（1）独占锁(排它锁):只能有一个线程获取锁
（2）重入锁:一个线程可以多次lock()
（3）公平/非公平锁:只针对上锁过程
（4）非公平锁:尝试获取锁,若成功立刻返回,失败则加入同步队列
（5）公平锁:直接加入同步队列
