JUC之Lock、ReentrantLock可重入独占锁
前言
ReentrantLock即可重入锁，实现了Lock和Serializable接口
在java环境下ReentrantLock和Synchronized都是可重入锁
ReentrantLock构造函数中提供两种锁：创建公平锁和非公平锁（默认）
- ReentrantLock有三个内部类 Sync、NonfairSync和FairSync类。
- Sync继承AbstractQueuedSynchronized抽象类
- NonfairSync（非公平锁）继承Sync抽象类。
- FairSync（公平锁）继承Sync抽象类。
公平锁，线程按照发出的请求的顺序获取锁；非公平锁，允许插队。
公平锁上，若有另外一个线程持有锁或有其他线程在等待队列中等待这个锁，那么新发出的请求的线程将被放入到对类中。
非公平锁性能高于公平锁性能的原因
- 在恢复一个被挂起的线程与该线程真正运行之间存在着严重的延迟
- 假设线程 A 持有一个锁，并且线程 B 请求这个锁。由于锁被 A 持有，因此 B 将被挂起。当 A 释放锁时，B 将被唤醒，因此 B 会再次尝试获取这个锁。与此同时，如果线程 C 也请求这个锁，那么 C 很可能会在 B 被完全唤醒之前获得、使用以及释放这个锁。这样就是一种双赢的局面，B 获得锁的时刻并没有推迟，C 更早的获得了锁，并且吞吐量也提高了。
当持有锁的时间相对较长或者请求锁的平均时间间隔较长，应该使用公平锁
公平锁保证了锁的获取按照FIFO原则，而代价是进行大量的线程切换。非公平锁虽然可能造成线程“饥饿”，但极少的线程切换，保证了其更大的吞吐量。
源码
ReentrantLock类是实现了Lock接口，先看看接口里的抽象方法
Lock API
void lock(); //获取锁
void lockInterruptibly() throws InterruptedException; //如果当前线程未被中断，则获取锁
boolean tryLock(); //只有锁在空闲状态时才能获取该锁。
boolean tryLock(long time, TimeUnit unit) throws InterruptedException; //锁在给定时间内空闲，且当前线程未被中断，则获取锁
void unlock(); //释放锁
Condition newCondition(); //返回绑定到此Lock实例的新 Condition 实例。
Lock接口中出现的Condition接口，它是什么作用呢？
Condition
wait()、notify()和synchronized配合可以实现等待通知，Condition和Lock配合同样也可以实现等待通知，但是两者之间还是有区别的
Condition定义了等待/通知两种类型的方法，当前线程调用这些方法，需要提前获取到Condition对象关联的锁，Condition对象是由Lock对象创建出来的(Lock.newCondition)，换句话说，Condition是依赖Lock对象的。
ConditionAPI
public interface Condition {
void await() throws InterruptedException; //当前线程进入等待状态直到被通知(signal)或被中断
void awaitUninterruptibly(); //不响应中断等待，直到被通知(signal)
long awaitNanos(long nanosTimeout) throws InterruptedException; //等待指定时长直到被通知或中断或超时
boolean await(long time, TimeUnit unit) throws InterruptedException; //同上
boolean awaitUntil(Date deadline) throws InterruptedException; //当前线程进入等待状态直到被通知、中断或者到某个事件。若没有到指定事件就被通知，方法返回true，否则false。
void signal(); //唤醒一个等待在Condition上的线程，该线程从等待方法返回前必须获得与Condition相关联的锁。
void signalAll(); //唤醒所有等待在Condition上的线程，该线程从等待方法返回前必须获得与Condition相关的锁
}
ReentrantLock源码
构造器
public ReentrantLock() {sync = new NonfairSync();} //默认使用非公平锁对象
public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();} //根据参数，判断使用 非公平/公平 锁。
内部类
构造器中，是创建内部类的对象NonfairSync（非公平锁）和FairSync（公平锁），它们都实现了Sync静态内部类
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) { //如果为0，当前锁未被其他线程获取
if (compareAndSetState(0, acquires)) { //通过CAS设置
setExclusiveOwnerThread(current); //设置获取锁的此线程
return true;
}
}
else if (current == getExclusiveOwnerThread()) { //如果锁状态不为0，则已经被其他线程获取。如果是当前线程，也就是同一个线程再次获取这个锁，即可重入
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) { //状态值为0，释放锁
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
//检查锁是否为此线程的所有者。就是之前是否是这个线程获取的锁
protected final boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
//创建ConditionObject对象
final ConditionObject newCondition() {
return new ConditionObject();
}
//返回该锁的线程
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
//返回锁的状态值。如果是该锁的线程，返回对应的值；不是返回0
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
}
}
NonfairSync非公平锁的源码实现
非公平锁就是一种获取锁的抢占机制，是 随机获得锁 的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了.
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
//执行锁
final void lock() {
if (compareAndSetState(0, 1)) //通过CAS操作，设置状态值
setExclusiveOwnerThread(Thread.currentThread()); //设置该锁的线程
else
acquire(1);
}
//尝试获取锁。默认是非公平锁，转至Sync中的方法
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
FairSync公平锁的源码实现
公平锁表示线程获取锁的顺序是按照 线程加锁的顺序 来分配的，即先来先得的 FIFO 先进先出顺序。
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
//执行加锁
final void lock() {
acquire(1);
}
//尝试获取锁
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread(); //当前线程
int c = getState(); //状态值
if (c == 0) { //等于0，该锁未被线程获取
if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { //hasQueuedPredecessors()方法判断头节点是否为当前线程
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) { //如果不等于0，判断该锁的线程是否为当前线程，是可重入。
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
方法
//获得锁
public void lock() {
sync.lock();
}
//当前线程未被中断，获取锁
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
//该锁未被其他线程获取，则当前线程获取锁。默认非公平锁
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);
}
//返回Condition对象
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();
}
//查询是否有线程正在等待与此锁关联的给定条件。
public boolean hasWaiters(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}
//返回与此锁关联的给定条件下等待的线程数的估计值。
public int getWaitQueueLength(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}
//返回一个集合，其中包含可能正在等待与此锁关联的给定条件的线程。
protected Collection<Thread> getWaitingThreads(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
}
总结
- ReentrantLock 提供了内置锁（synchronized）类似的功能和内存语义。
- ReentrantLock 提供了包括定时的锁等待、可中断的锁等待、公平性以及实现非块结构的加锁。
- Condition 对线程的等待和唤醒等操作更加灵活，一个 ReentrantLock 可以有多个 Condition 实例，更有扩展性。
- ReentrantLock 需要显示的获取锁，并在 finally 中释放锁。
- JDK 1.8 以前 ReentrantLock 在性能上似乎优于 synchronized，但获取锁的操作不能与特定的栈帧关联起来，而内置锁可以。
- 因为内置锁时 JVM 的内置属性，所以未来更可能提升 synchronized 而不是 ReentrantLock 的性能。
- 例如对线程封闭的锁对象消除优化，通过增加锁粒度来消除内置锁的同步。
