@[TOC]
前言
了解ReentrantLock的原理和底层实现
一、ReentrantLock是如何实现的？
ReentrantLock 主要利用CAS 和 AQS队列实现，并且支持公平锁和非公平锁。
CAS：Compare and Swap，比较并交换。在java中，CAS主要由Unsafe类通过JIN调用CPU底层代码实现。
CAS有三个参数：内存值V、预期值A、新值B。当且仅当，预期值A和内存值V相同时，将内存值修改为B，否则不做修改。
关于AQS，参见文章AQS队列
二、lock 和 unlock的过程分析
2.1 ReentrantLock的两个构造器
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
默认构造器会将其实例化为NonfairSync对象，即非公平锁，而带参数的构造器可以指定使用公平锁还是非公平锁。
2.2 lock过程
NonfairSync.lock
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
非公平锁的lock方法中，首先是一个CAS操作，判断state是否是0，即当前锁是否被其他线程占用了；如果是0，则设置为1，且设置当前线程为独占线程。这里CAS操作避免了并发操作的问题。
这里也是第一处体现非公平锁：如果此处占用锁的线程刚刚好释放锁，则当前线程可以直接获取锁，而无需排队，相当于直接“插队”。
若此处没有设置成功，即没有获取锁，则会执行acquire()方法。
acquire()
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
第一步是调用tryAcquire()方法，尝试获取锁。
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) { //状态为0，没有线程占用锁
if (compareAndSetState(0, acquires)) {
//与lock方法里一样，直接获取锁
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; // 获取锁失败，返回false
}
这里第二次体现了不公平锁。
这里还检验了是不是当前线程已经获取锁，而又重新获取锁。这里体现了重入锁。会更新状态值为重入的次数。
第二步addWaiter(Node.EXCLUSIVE)。
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
这个添加到队列的方法在上篇文章AQS已经分析过了，就不详细分析了。
第三步acquireQueued()，此方法是让队列中的线程尝试获取锁，如果失败则挂起线程。
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true; // 标记是否获取锁成功
try {
boolean interrupted = false; // 线程中断标志
for (;;) { // 自旋
final Node p = node.predecessor(); // 获得前驱节点
// 如果该节点的前驱节点是head，则该节点是队列中的第一个线程，可以尝试互殴去锁
if (p == head && tryAcquire(arg)) {
setHead(node); // 获取锁成功
p.next = null; // help GC，不然GC无法回收
failed = false; // 获取锁成功
return interrupted; //返回中断标志，没有被中断
}
// 如果获取失败，是否可以挂起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node); // 最后取消尝试获取锁
}
}
当上述方法获取锁失败之后，就会判断线程是否需要挂起。下面说明下shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()方法。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
// 前驱节点的状态
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true; // 如果前驱节点状态是SIGNAL，则返回true，可以挂起
// 前驱节点是CANCELLED
if (ws > 0) {
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
// 从队尾向前循环查找，直到找到第一个不为CANCELLED的节点
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
// 设置前驱节点状态为SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
// 挂起当前线程，并返回线程中断状态
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
这里解释下，线程挂起的前提是，前驱节点是SIGNAL状态。那SIGNAL状态的含义是什么？SIGNAL表示其前驱节点线程如果获取锁，退出队列，则将其唤醒。
2.3 unlock过程
unlock
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
if (tryRelease(arg)) { // 尝试释放锁
Node h = head; // 获取头节点
if (h != null && h.waitStatus != 0)
unparkSuccessor(h); // 如果头节点不为空且不为状态不为0，则取消挂起
return true; // 释放成功
}
return false; // 释放失败
}
这里先尝试释放锁，如果成功，就将头节点取消挂起。
tryRealase
protected final boolean tryRelease(int releases) {
// 当前锁状态值减去释放值，注意考虑重入锁，不是直接置为0
int c = getState() - releases;
// 如果不是当前线程占用锁，则抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) { // 如果状态值等于0，则释放锁成功
free = true;
// 清空独占线程
setExclusiveOwnerThread(null);
}
// 更新state 值
setState(c);
return free;
}
三、公平锁和非公平锁的区别
下面介绍非公平锁和公平锁的区别，公平锁在获取锁之前， 不会直接CAS去获取锁，而是先判断当前锁状态是不是等于0且当前线程是不是队列中第一个线程，state=0才去尝试获得锁。
protected final boolean tryAcquire(int acquires) {
// 获取当前线程
final Thread current = Thread.currentThread();
// 获取锁状态
int c = getState();
if (c == 0) { // 如果锁没有被任何线程拥有
// 当前线程是CLH队列的的第一个线程，则取获取锁
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;
}
}
四、Synchronized和ReentrantLock的区别
4.1 功能区别
Synchronized是Java语言的关键字，是通过JVM实现的。
ReentrantLock是API层面的一种互斥锁，而且它的锁粒度和灵活性都优于Synchronized。
Synchronized使用较为简单方便，由编译器去保证锁的加锁和释放。而ReentrantLock需要手动加锁和释放锁，如果忘记手工释放锁，会造成死锁。
4.2 性能区别
在Synchronized优化之前，性能是比较差的，因为都是重量级锁。但是Synchronized引入偏向锁，轻量级锁之后，两者的性能相差不大。当不需要使用ReentrantLock的特有性质时，官方建议使用Synchronized。
4.3 ReentrantLock的特有性质
等待可中断：持有锁的线程长期不释放的时候，正在等待的线程可以选择放弃等待，这相当于Synchronized来说可以避免出现死锁的情况。通过lock.lockInterruptibly()来实现这个机制。
公平锁：多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁是非公平锁，ReentrantLock可以实现公平锁。
选择性通知（锁绑定多个条件）：一个ReentrantLock可以同时绑定多个对象，然后通过condition（条件）类，来分组唤醒线程，而Synchronized是随机唤醒一个线程或者所有线程。
