Lock互斥锁的实现原理总结。
目录
前言
ReentrantLock 是JDK1.5 引入的J.U.C包中的一个比较重要的可重入的、互斥的并且支持公平和非公平的锁，其实现了 Lock接口，其内部是通过 AQS + CAS 原理实现的。其具备 synchronized 关键字加锁的所有功能，并且还具备一些 synchronized 锁不具备的功能，比如：尝试拿锁，支持中断、支持超时等待等。
互斥锁
锁的可重入性
可重入锁是指当一个线程调用object.lock()拿到锁，进入互斥区后，再次调用object.lock()，仍然可以拿到该锁。很显然通常的锁都应该设计为可重入的，否则会发生死锁。
类的继承结构
A表示抽象类，C表示类，I表示接口
Lock接口的定义如下：
public interface Lock {
// 获取锁
void lock();
// 获取锁（可中断）
void lockInterruptibly() throws InterruptedException;
// 尝试获取锁，如果没获取到锁，就返回false
boolean tryLock();
// 尝试获取锁，如果没获取到锁，就等待一段时间，这段时间内还没获取到锁就返回false
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
// 释放锁
void unlock();
// 条件锁
Condition newCondition();
}ReetrantLock本身没有代码逻辑，实现都在其内部类Sync中。
锁的公平性和非公平性
Sync是一个抽象类，它有两个子类FairSync和NonfairSync，分别对应为公平锁和非公平锁。公平锁就是排队申请资源，非公平锁就是线程来了之后直接去抢锁。这里默认设置的是非公平锁，原因是为了提高效率，减少线程切换。
public ReentrantLock() {
sync = new NonfairSync(); //默认为非公平锁
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync(); //fair为是否是公平
}锁实现的基本原理
为了实现一个具有阻塞唤醒功能的锁，需要几个核心要素：
1.需要一个state变量，标记该锁的状态。主要用于实现锁的可重入和竞争。使用CAS保证线程安全。
2.需要记录当前是哪个线程持有锁。
3.需要底层支持对一个线程的阻塞唤醒。
4.需要有一个队列维护所有阻塞的线程。这个队列必须是安全且无锁的(因为我们就是为了实现锁)。所以也需要使用CAS。
针对1,2，在上面两个类中实现了。
public abstract class AbstractOwnableSynchronizer{
.....
private transient Thread exclusiveOwnerThread; // 记录持有锁的线程
.....
}
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
......
private volatile int state; // 记录当前的锁的同步状态，是通过 CAS 操作。
......
}针对第三条Unsafe类中提供了阻塞和唤醒线程的一对操作源语，park/unpark。
LockSupport工具类对这对原语进行了简单封装。
public class LockSupport {
//禁用当前线程的线程调度
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
UNSAFE.park(false, 0L); // 最终调用的是 Unsafe类中的 park 方法
setBlocker(t, null);
}
// 唤醒 指定的线程
public static void unpark(Thread thread) {
if (thread != null)
UNSAFE.unpark(thread); //最终调用的是 Unsafe类中的 unpark 方法
}
}unpark(Thread thread)实现了线程的精准唤醒。
针对第四点在AQS中利用CAS实现了一个阻塞队列。
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
static final class Node { // 节点
volatile Thread thread; // 当前线程引用
volatile Node prev; // 前置节点
volatile Node next; // 后续节点
}
private transient volatile Node head; // 头结点
private transient volatile Node tail; // 尾结点
......
}公平和非公平的lock()的实现差异
非公平锁：
static final class NonfairSync extends Sync {
final void lock() {
// 上来就更改 state 状态，也就是抢锁
// 不考虑队列中有没有其他线程在排队，体现了非公平锁
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());// 如果抢成功则设置锁的拥有者为当前线程
else
acquire(1); // 如果抢占失败则进行重新申请
}
}公平锁：
static final class FairSync extends Sync {
final void lock() {
acquire(1); // 没有上了就抢锁，而是调用此方法，进行排队。
}
}acquire()是AQS的一个模板方法，如下所示。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //在AQS加一个独占线程，无限期阻塞直到拿到锁返回是否期间收到中断信号
selfInterrupt(); //设置中断标志，期间收到中断线程不会响应，此时进行一个补偿机制。
}
static void selfInterrupt() {
Thread.currentThread().interrupt();
}其内部的 调用 tryAcquire(int arg) 方法尝试拿锁，但是，tryAcquire() 方法是个空方法，需要子类进行去实现。那么在看看 NonfairSync (非公平锁) 和 FairSync (公平锁) 对这个方法的实现差异。
//非公平锁
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {// 如果当前 state 为0，就更新state的状态不考虑有没有线程排队
//如果更新成功则设置锁的所有者为当前线程
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//如果 state 不为0 表示锁已被占用，则判断锁的拥有者是否为当前线程
//如果是当前线程 则 state 加 1；
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 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;
}唯一的区别在于公平锁多了一个限制条件：当前线程必须排在队列的第一个。
阻塞队列与唤醒机制
在上面的 acquire() 方法中可以看到，当调用 tryAcquire() 方法返回 false 后回调 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)，此方法的作用就是把当前线程构造成一个Node节点，然后进行阻塞。
先说addWaiter（..）函数，就是为当前线程生成一个Node，然后把Node放入双向链表的尾部。要注意的是，这只是把Thread对象放入了一个队列中而已，线程本身并未阻塞（Node.EXCLUSIVE 表示构造一个独占节点）。
private Node addWaiter(Node mode) {
// 把申请资源的当前线程 构造成一个 Node 节点 mode 为模式( 独占 或 共享 )
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail; // 取到尾结点
if (pred != null) { //如果尾结点不为空 则尝试把新构建节点 同 CAS 操作插入到尾部
node.prev = pred;
if (compareAndSetTail(pred, node)) { // 先尝试把节点加入到队列尾部，如果不成功则调用下
pred.next = node; // 面的 enq 方法通过 CAS + 自旋的方式加入到队列尾部
return node;
}
}
enq(node); // 如果 插入失败，则进行“自旋 + CAS” 操作插入尾部。如果未初始化会在enq中进行初始化再自旋CAS插入。
return node;
}调用addWaiter(mode) 方法把包含 Thread 对象的节点加入阻塞队列之后的工作就会调用 acquireQueued() 方法来完成线程的阻塞功能。线程一旦进入acquireQueued() 就会被无限期阻塞，即使有其他线程调用 interrupt() 方法也不能将其唤醒，除非有其他线程释放了锁，并且该线程拿到了锁，才会从accquireQueued() 返回。注意：进入acquireQueued()，该线程被阻塞。在该函数返回的一刻，就是拿到锁的那一刻，也就是被唤醒的那一刻，此时会删除队列的第一个元素（head指针前移1个节点）。
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true; // 标记是否失败
try {
boolean interrupted = false; // 标记是否被中断
for (;;) {
final Node p = node.predecessor(); //获取到当前节点的前驱节点
//第一次进入或者被唤醒，如果其前驱节点为头结点，则会尝试拿锁。
// 如果拿锁成功则会出队，即把自己设置为头结点，
// 如果拿锁失败则阻塞等待
if (p == head && tryAcquire(arg)) {
setHead(node); // 果是头结点 且获取资源成功, 把当前节点设置为头结点
p.next = null; // help GC
failed = false;
return interrupted;
}
//如果自己可以休息了，就通过park()进入waiting状态，直到被unpark()。
// 如果不可中断的情况下被中断了，那么会从park()中醒过来，发现拿不到资源，从而继续进入park()等待。
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}当acquireQueued() 方法返回true时，回调selfInterrupt()方法自己给自己发送中断信号，也就是自己把自己的中断标志位设为true。之所以要这么做，是因为自己在阻塞期间，收到其他线程中断信号没有及时响应，现在要进行补偿。这样一来，如果该线程在lock代码块内部有调用sleep（）之类的阻塞方法，就可以抛出异常，响应该中断信号。
接下来我们在看看 acquireQueued() 方法中对线程的阻塞部分。在线程进行阻塞之前会先判断此线程需不需要阻塞。如下所示：
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus; // 前驱节点状态
if (ws == Node.SIGNAL) //如果前驱节点的状态为 SIGNAL 返回出则进行阻塞
return true;
if (ws > 0) { // 如果前驱节点已取消(超时或者被中断)，则节点往前移，把已取消的节点
// 都移除调用
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 否则把前驱节点的状态更新为 SIGNAL 也就是当前驱节点释放
// 锁后唤醒当前线程去抢锁。
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}如果调用 shouldParkAfterFailedAcquire() 方法返回ture,则当前线程进行休眠等待，具体操作如下：
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this); // 进行休眠
return Thread.interrupted(); // 当被唤醒后返回当前线程是否被中断过
}parkAndCheckInterrupt 方法中调用 park() 方法使当前线程进行休眠，也就是自己把自己阻塞起来，直到被其他线程唤醒，该函数返回。park() 函数返回有两种情况。
情况1：其他线程调用了unpark()。
情况2：其他线程调用了t.interrupt()。
需要注意的是，lock() 不能响应中断，但 LockSupport.park() 会响应中断。也正因为LockSupport.park() 可能被中断唤醒，所以 acquireQueued() 方法才写了一个for死循环。唤醒之后，如果发现自己排在队列头部，就去拿锁；如果拿不到锁，则再次自己阻塞自己。不断重复此过程，直到拿到锁。被唤醒之后，通过 Thread.interrupted() 来判断是否被中断唤醒。如果是情况1，会返回false；如果是情况2，则返回true。
unlock()实现分析
unlock不区分公平还是非公平。
// 释放锁 ReentrantLock 中的方法
public void unlock() {
sync.release(1); // 释放锁 AbstractQueuedSynchronizer 中的方法，state - 1
}
// 释放锁 AbstractQueuedSynchronizer 中的模板方法
public final boolean release(int arg) {
//通过 tryRelease 尝试释放资源
if (tryRelease(arg)) {
Node h = head; //获取头结点
//判断头结点不null，为非初始状态，则执行唤醒操作
if (h != null && h.waitStatus != 0)
unparkSuccessor(h); // 唤醒后续节点
return true;
}
return false;
}
// ReentrantLock.$Sync 中的方法
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
// 只有拥有锁的线程才能释放锁，否则 抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) { //没调用1次tryRelease，state 减 1 直到 为0才才表示锁释放成功
free = true;
setExclusiveOwnerThread(null);
}
setState(c); // 关键点：因为是排他锁，只有获取锁的线程才可以调用tryRelease方法进行释放锁，
// 所以此处 没有使用 CAS 操作。
return free;
}通过分析源码 我们知道调用 unlock() 方法实际是调用了 AQS中的 release()方法。release() 里面做了两件事：一是调用 tryRelease() 方法释放锁；一是调用 unparkSuccessor() 方法唤醒队列中的后继者。
private void unparkSuccessor(Node node) {
int ws = node.waitStatus; // 获取节点的状态
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//unpark的线程被保存在后续节点中，后者通常只是下一个节点。
// 但如果取消或明显为空，则从尾部向后遍历，以找到实际未取消的后继项
Node s = node.next; // 获取头结点的后续节点
// 如果后续节点为null,或者 状态为已取消 (超时 或 被中断)
// 侧从 尾结点开始变量，找到第一个未放弃的线程
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null) // 如果找到未放弃的线程 则进行唤醒操作
LockSupport.unpark(s.thread);
}lockInterruptibly()实现分析
lockInterruptibly()是可以中断的，lock()是不能被中断的。
// ReentrantLock 中方法
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
// AbstractQueuedSynchronizer 中方法
public final void acquireInterruptibly(int arg) throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (!tryAcquire(arg))
doAcquireInterruptibly(arg);
}从上面代码中我们可以发现，acquireInterruptibly() 也是AQS中的一个模板方法，其内部调用 tryAcquire() 方法与上面lock方法是一样的，在此不再赘序。我们重点看下 doAcquireInterruptibly() 方法。
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException(); // 关键点这里收到中断信号后，不再进行阻塞
// 而是直接抛出中断异常
}
} finally {
if (failed)
cancelAcquire(node);
}
}其实现原理与 accquireQueued() 方法非常相似，主要的区别就是，当parkAndCheckInterrupt() 返回 true 的时候，说明有其他线程发送中断信号，直接抛出InterruptedException，跳出for循环，整个函数返回。
unlock()实现分析
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}tryLock() 实现基于调用非公平锁的tryAcquire()，对state进行CAS操作，如果操作成功就拿到锁；如果操作不成功则直接返回false，也不阻塞。
227
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
