ReentrantLock
简略版总结
AQS
AQS，全称为 AbstractQueuedSynchronizer，是 Java 中 java.util.concurrent 包的一部分。作为构建锁或其他同步工具（如信号量、倒计时闸门等）的基础框架;
同步队列： AQS 内部维护了一个 FIFO（先进先出）队列，这个队列用来保存等待获取锁的线程。当一个线程尝试获取锁失败时，它会被加入到这个队列中。
状态管理： AQS 通过一个 volatile 的整型 state 字段来表示同步状态。例如锁的获取和释放都可以通过修改 state 来实现。比如，state 为 0 表示锁是空闲的，为 1 表示锁已经被占用。
模板方法设计： AQS 使用了模板方法设计模式，比如 acquire 方法, 它调用了 tryAcquire, addWaiter 等方法，子类可以根据需要进行实现。比如
ReentrantLock 就实现了 tryAcquire 方法;
例如, ReentrantLock 就是基于 AQS 实现的, 内部类 NonFairSync 和 FairSync 都间接继承了 AQS, 分别作为 非公平可重入锁 和 公平可重入锁的实现;
公平锁 lock():
- 直接去调用 acquire 模版方法;
- aquire 内部调用 tryAcquire方法, 如果AQS.state == 0 && 等待队列中没有元素, CAS获取锁; 获取失败则判断是否是可重入;
- acquire 内部调用 addWaiter方法, tryAcquire 获取失败以后, 以 CAS 的方式将当前线程加入等待队列尾部;
非公平锁 lock() :
- 上来就先CAS, 失败再调用 tryAcquire
- tryAcquire内部, 如果 AQS.state == 0 直接尝试CAS, 不管队列里有没有元素; 失败则判断是否是重入情况?
- acquire 内部调用 addWaiter 方法, CAS的方式加入队尾;
加入队尾后的处理都一样, 即 acquireQueued 方法:
循环 {
我是第一个元素
尝试CAS获取锁(成功则将自己置为head必挂return);
不是{
如果前一个结点状态合法,
那么我LockSupport.park();
否则,
向前遍历, 删除自己前面所有状态为 Cancel 的结点, 我不挂起, 进入下一轮检查;
}
}
unlock ():
-
检查调用线程是否是当前锁的 ExclusiveOwner, 如果是, 判断锁值, 看是不是可重入的情况;
-
如果锁值 - 1已经是0, 则修改 exclusiveOwner 释放锁, 修改 AQS 的 state, 然后选择队列里的一个结点唤醒;
-
选择依据: 判断 head.next 是否合法, 如果合法, 唤醒它; 如果不合法, 从后往前遍历, 找到最靠前的合法结点唤醒;
从后往前是因为添加的时候先设置的 tail.pre 和 tail;
Cancel 状态不合法, 什么样的 Node 会进入Cancel 状态? tryLock 超时的, 调用 lockInterruptly 方法的, 可以通过Interrupt 打断正在阻塞的线程;
-
被唤醒的节点应该正在 acquireQueued 方法里循环;
公平 / 非公平
- 无参构造方法默认是非公平锁
- 有参构造方法传入true是公平, false是非公平锁
详细分析
AQS
-
ReentantLock中有内部类Sync, 该类继承了AbstractQueuedSynchronizer; ReentrantLock的lock方法调用了Sync类的lock方法;
-
Sync有两个子类, 分别是公平锁和非公平锁
-
AQS内部有一个内部类Node, 由Node构成了双向链表, Node有以下成员
static final Node SHARED = new Node(); static final Node EXCLUSIVE = null; // 调用tryLock()方法, 等待了一定时间以后, 不等了, 状态就是CANCELLED static final int CANCELLED = 1; // 被挂起的状态 static final int SIGNAL = -1; // 和Condition相关的状态, 可以正常转换为 -1 static final int CONDITION = -2; // 共享锁相关, 可以正常转换为-1 static final int PROPAGATE = -3; volatile int waitStatus; // 双向链表 volatile Node prev; // 双向链表 volatile Node next; // 对应的Thread volatile Thread thread; Node nextWaiter; -
AQS有成员head, tail, state;
head指向双向链表的头结点; tail指向尾结点; 使用的是带虚拟头结点的队列
获取锁的本质就是通过CAS操作将AQS的 volatile state 改为1;
-
AQS有成员
private transient Thread exclusiveOwnerThread;在排它锁的实现下, 指向当前锁的持有线程;
lock( )
- 调用了Sync的lock方法, 根据具体公平锁还是非公平锁, 有两套实现
- 记住, 公平锁和非公平锁都是AQS的子类
非公平锁
final void lock() {
// 通过CAS尝试将AQS的state从0改为1
if (compareAndSetState(0, 1)){
// 将当前线程设置为AQS的exclusiveOwner(继承自AOS), 用于可重入;
setExclusiveOwnerThread(Thread.currentThread());
}
else
// 获取锁失败, 调用acquire(1);
acquire(1);
}
公平锁
final void lock() {
acquire(1);
}
acquire( )
-
公平锁和非公平锁都是一样的, 都继承自AQS
if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt();
tryAcquire(arg)
-
AQS的实现是抛出异常, 真正用到的是子类公平锁和非公平锁的实现
-
FairSync实现
// acquires一般就是1 protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); // 获取当前AQS的状态 int c = getState(); // 如果没被锁 if (c == 0) { // 判断等待队列中除了自己以外(acquireQueued方法也会调用此方法)是否有其它线程 if (!hasQueuedPredecessors() && // 如果没有, 尝试通过CAS操作获取锁 compareAndSetState(0, acquires)) { // 如果获取到, 修改AQS的exclusiveOwner setExclusiveOwnerThread(current); return true; } } // 判断自己是否已经获取过该锁 else if (current == getExclusiveOwnerThread()) { // 如果已经获取过, state + 1 int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } // 如果没有成功获取到锁, 返回false return false; } -
NonefairSync的 tryAquire 方法直接调用了nonfairTryAcquire
final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); // 如果AQS的状态为0, 不管队列里有没有线程, 自己先试一下CAS, 成功了就设置exclusiveOwner, 返回true 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; }
addWaiter( )
-
如果tryAcquire没有成功获取到锁, 那么需要将当前线程添加到AQS的等待队列中
-
这个方法公平锁和非公平锁的实现都一样, 使用AQS中的实现
public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); } // 这里会传入Node.EXCLUSIVE, 是一种标记, 标记当前是互斥锁; private Node addWaiter(Node mode) { // 将tryAcquire获取锁失败的线程封装成Node Node node = new Node(Thread.currentThread(), mode); Node pred = tail; // 如果队列非空, 尝试用CAS操作将封装好的node添加到AQS等待队列的队尾; if (pred != null) { node.prev = pred; // 参数分别是tail的当前期望与修改目标, 如果当前值是pred, 那么将其修改为node, 修改成功 // 否则, 说明有其他线程也在更新tail, 当前CAS失败, 进入enq; if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } // 如果队列空或者cas添加到队尾失败, 那么调用enq保证一定插入到队列中 enq(node); return node; } private Node enq(final Node node) { // 通过死循环不断自旋地进行CAS操作, 确保插入成功; for (;;) { Node t = tail; // 如果队列为空, CAS操作尝试创建一个dummy队头 if (t == null) { if (compareAndSetHead(new Node())) tail = head; } else { // 如果队列非空, 使用CAS操作尝试添加到队尾 node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } } }
acquireQueued
-
公平和非公平都一样, 使用AQS中的实现
// 传入的参数是addWaiter用当前线程构建出的Node对象和 1 final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { // 标记方法返回之前是否被挂起过 boolean interrupted = false; for (;;) { // 拿到 当前线程对应的结点 的前一个结点 final Node p = node.predecessor(); // 前一个结点是head, 那么说明自己是第一个有效的结点 // 调用tryAcquire方法尝试获取锁, 如果获取成功, 将自己作为新的head if (p == head && tryAcquire(arg)) { setHead(node); p.next = null; // help GC failed = false; // 唯一的退出途径 return interrupted; } // 如果不是第一个有效结点, 判断当前线程是否可以挂起 if (shouldParkAfterFailedAcquire(p, node) && // 通过判断, 挂起当前线程 // 被唤醒后, 继续在死循环中去判断当前线程是否是第一个有效结点 // 这就是在队列中等待获取锁的原理, 如果一直不是第一个有效节点, 就会一直被困在acquireQueued方法中挂起, 唤醒, 挂起, 唤醒 parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); } } private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { int ws = pred.waitStatus; // 如果前一个结点状态为 -1, 可以挂起, 返回true, 只有这一种情况返回true // 其它情况都都不会挂起, 而是要等到下一次在acqiredQueued内的循环中才能返回true; if (ws == Node.SIGNAL) return true; // 如果前一个结点状态是1, CANCEL, 那么不断向前寻找, 找到第一个状态不是1的结点, 删除这个过程中经过的所有状态为CANCEL的结点 if (ws > 0) { do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } // 如果前一个结点是0, -1, -2, 通过CAS操作将其状态修改为 -1 else { compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false; }
unlock( )
public void unlock() {
// 每次只释放1
sync.release(1);
}
- 调用了 sync 的 release方法, 该方法公平锁和非公平锁的实现都是一样的, 来自于AQS
public final boolean release(int arg) { // arg = 1
if (tryRelease(arg)) {
Node h = head;
// 如果需要释放锁, 并且当前线程队列中有等待唤醒的线程
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
- 调用了Sync的tryRelease, 公平非公平的实现一样
protected final boolean tryRelease(int releases) { releases = 1
// state - 1;
int c = getState() - releases;
// 判断当前线程是否是该锁的Owner, 如果不是, 抛异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 如果释放后state为0, 返回一个锁已经释放的标记
if (c == 0) {
free = true;
// exclusiveOwnerThread 置为 null
setExclusiveOwnerThread(null);
}
// 如果state不是0, 说明是锁重入的情况, 不需要释放锁
setState(c);
return free;
}
- AQS的unparkSuccessor
private void unparkSuccessor(Node node) {
// 头结点状态如果 -1, -2, -3, CAS改为0
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 拿到头结点下一个结点, 因为头结点是dummy
Node s = node.next;
// 如果s无效(==null或CANCELLED), 从后往前遍历Node, 找到最接近head的有效Node
if (s == null || s.waitStatus > 0) {
s = null;
// 为什么从后往前, 因为在addWaiter时, 先连接了prev指针, 再连接的next指针, 从后往前遍历能确保多线程情况下遍历到最新添加的Node
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 如果找到有效的Node, 唤醒对应的Thread
if (s != null)
LockSupport.unpark(s.thread);
}
扫一扫
1167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
