AbstractQueuedSynchronizer与ReentrantLock
介绍
j.u.c包中的Lock
定义了锁的行为。
而ReentrantLock
是并发包下提供的一个锁的实现,它是一个可重入的、排他的锁。
ReentrantLock
有的属性也很简单,除了一个serialVersionUID
外,只有一个sync
。
ReentrantLock
可以分为公平锁和非公平锁两种。可以在创建时,通过向构造函数传入fair
参数指定:
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
无参的构造函数默认会创建一个非公平锁。公平锁和非公平锁的主要区别是:公平锁会保证在锁空闲时,先申请的线程先得到锁;而非公平锁则不考虑线程申请锁的先后顺序,随机让一个线程获得锁。
通过上文的构造函数我们也可以看到,其实内部负责锁的工作的是Sync
。
ReentrantLock
内部定义了一个抽象类Sync
,定义了基本锁的行为,然后通过两个具体子类FairSync
和NonfairSync
调整具体实现细节,控制公平和非公平的实现(模版模式)。
Sync
类继承自AbstractQueuedSynchronizer
(AQS)。AQS
是并发包中实现所有锁的基础(无论是共享锁/排他锁,可重入锁/不可重入锁)。其基本思想就是维持一个队列,队列中的每个节点保存了需要获取锁的线程,当线程无法获取锁时,会被Park从而进入WAITING状态,而当一个线程释放锁时,会从队列中选择一个节点的线程unPark。AQS
通过CAS
的操作和LockSupport
类,在不用synchronize
的情况下,实现了锁(因而效率也比synchronize
要高)。
我们就通过对ReentrantLock
上锁以及释放锁的过程进行分析,了解AQS
。
在分析AQS
前,同样对AQS
内部拥有的变量做个分析。
AQS
的成员变量主要可以分为三个类型(除序列化号外):
- CAS操作相关:
这部分主要是UNSAFE
对象及AQS
各属性的地址偏移量字段。
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;
static {
try {
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
headOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("head"));
tailOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
waitStatusOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("waitStatus"));
nextOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("next"));
} catch (Exception ex) { throw new Error(ex); }
}
- 锁的状态和持有者
AQS
用state表示锁的状态,state = 0时,表示锁未被持有,而当state > 0时,表示锁被持有,且state表示被持有的次数
private volatile int state;
AQS
继承了AbstractOwnableSynchronzier
,后者用一个字段表示当前持有锁的线程。可以通过该字段得到锁的持有者。
private transient Thread exclusiveOwnerThread;
AQS
维护的队列相关
AQS
中定义了一个内部类Node
,表示一个节点,节点构成双向链表,形成队列。
static final class Node {
//节点内部有一个特殊的指针,指向特殊的Node,用来表示这个节点的模式,共享/排他
static final Node SHARED = new Node();
static final Node EXCLUSIVE = null;
/*********节点的状态常量**********/ //取消(表示该节点等待锁的线程已经取消)
static final int CANCELLED = 1;
//信号量 表示该节点需要负责后续节点的唤醒
static final int SIGNAL = -1;
static final int CONDITION = -2;
static final int PROPAGATE = -3;
//表示节点的状态
volatile int waitStatus;
//指向前继节点的指针
volatile Node prev;
//指向后继节点的指针
volatile Node next;
//节点代表的线程
volatile Thread thread;
//特殊的指针,表示节点的模式
Node nextWaiter;
//是否是共享模式
final boolean isShared() {
return nextWaiter == SHARED;
}
//获取前继节点
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
Node() {
}
Node(Thread thread, Node mode) {
this.nextWaiter = mode;
this.thread = thread;
}
Node(Thread thread, int waitStatus) {
this.waitStatus = waitStatus;
this.thread = thread;
}
}
AQS
内部有两个字段保存链表的头节点和尾节点。
private transient volatile Node head;
private transient volatile Node tail;
ReentrantLock的上锁过程
阻塞lock()
lock()
是一个阻塞的方法,线程会一直阻塞,直到成功获取锁。lock()
方法内部实现很简单,将上锁的操作委托给sync
,由sync.lock()
方法实现。
sync.lock()
方法对于FairSync
和NonfairSync
的实现是不一样的,本文只针对公平锁分析。非公平锁的流程留给读者自行学习。
FairSync.lock()
内部是通过acquire(1)
实现。
acquire()
方法主要分为两步:
-
先调用
tryAcquire()
尝试获取锁protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); //判断是否被持有 if (c == 0) { //由于是公平锁,即使未被持有,也有看队列中是否有在自己之前等待锁的线程 if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { //如果没有则用CAS更新state,并设置线程持有者 setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { //判断持有者是否为当前线程 //锁被重入,更新state值 int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; }
对于公平锁而言,
tryAcquire()
只会在以下几种情况返回true
:
1)线程本就是锁的持有者,此时线程只是重入锁,
2)锁未被其他线程持有且没有其他线程排在该线程之前要获得锁。 -
如果尝试获取锁失败,则构建一个代表该线程的节点添加至队列,并将线程Park,等待前继节点释放锁时,唤醒该线程。
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
因为ReentrantLock
是排他的,所以在添加节点中,添加了一个排他的节点(模式为Node.EXCLUSIVE
)。
添加进队列,并Park线程的操作主要在acquitrQueued
中。
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线程,如果需要则Park线程
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed) //唤醒失败,将这个节点的waitingStatus更新为CANCELLED
cancelAcquire(node);
}
}
首先acquireQueued
在外层套了一个自循环,可以让线程在获取锁失败后继续尝试以及避免线程的假唤醒。
第一个if
分支,是判断该线程是否可以去获取锁,并是否获取成功,如果获取成功,则更新等候链表的头节点,并释放旧的头节点。
到第二个if
分支时说明线程获取锁失败了,此时需要检查是否需要Park线程(此时一般说明该线程还没到实际去获取锁,因此Park掉线程,不让他一直尝试,浪费CPU时间)。
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 {
//更新状态
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
返回false
的情况后,线程会继续去尝试获取锁,如果再次失败依旧会进入到第二个分支并被决定是否要被Park。
线程会一直在acquireQueued()
这个方法内阻塞,直到线程能够获取锁或是线程在上锁过程异常退出才会返回,lock方法才会执行结束。
公平锁和非公平锁的区别
其实公平锁和非公平锁的区别只在于当线程第一次获取锁时,公平锁在线程第一次获取锁时,除了考虑锁是否被持有,还会考虑是否有其他线程在此线程之前获取锁(会主动把机会让给先尝试获取的线程)并自己入队;
而非公平锁在第一次加锁时,只考虑锁是否空闲,不考虑队列中已经有等待的线程。但是如果第一次上锁失败,线程也同样会入队,等待前继节点唤醒它。
ReentrantLock的释放锁过程
ReentrantLock.unlock()
Lock
接口定义了多种上锁的方式,lock()
(阻塞直到成功),tryLock()
(尝试上锁,无论结果直接返回),tryLock(t)
(在规定时间内尝试,超时未成功则返回失败),lockInteruptibly()
(阻塞上锁,但是外部可中断)。然而对释放锁的过程就只定义了一种unlock()
。
unlock()
实现也比较简单,ReentrantLock
同样把释放的动作委托给sync.release(1)
:
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
Sync
会调用tryRelease()
尝试释放锁,如果释放成功,则考虑唤醒队列中的后继节点的线程。
对于trtRelease()
而言,只要是排他锁(无论是公平还是非公平)流程都是一样的,因此这部分实现被提取到了抽象父类Sync
中:
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;
}
是否能释放,主要取决于操作的线程是否是锁的持有者,如果不是,会抛出IllegalMonitorStateException
异常。如果是,则将锁的state
值更新(减去释放的次数)。如果值已经更新为0,则说明锁已经被完全释放,清空锁的持有线程,最后返回释放结果。
如果释放成功,释放的线程还有责任要唤醒后继线程去获取锁。
private void unparkSuccessor(Node node) {
//更新node节点的值
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//从链表尾部向前遍历,找到node节点的后继节点s
Node s = node.next;
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;
}
//如果s存在
if (s != null)
//唤醒后继节点的线程
LockSupport.unpark(s.thread);
}
以流程图的形式再回顾下lock和unlock过程
总结
如果将ReentrantLock
的控制方式(公平锁为例)做个重口味的比方,就类似一群人排队去WC。当你跑到WC想要去方便时,看见门开着,而且没有其他人在排队(锁未被占有且AQS
的队列没有其他线程在排队),你就可以自己先占好包厢,并且把门一关,这时候门上就提示有人(设置state
和exclusiveOwnerThread
)。其他人再想来只能在外边排起队来(addWaiter
进AQS
的队列),而且其他人为了不浪费时间刷起了手机不在一直看WC有没有人(线程被Park起,让出CPU时间),期间你可能弄出了些动静,惊动了排队的人,他们会检查下是否轮到自己了,发现还没有后,依旧玩起了手机(被错误唤醒的线程继续被Park)。直到你方便完,你主动打开了包厢门,然后找到队列中第一个排队的人,告诉他说:哥们儿,轮到你了,请自便(tryRelease并且unparkSuccessor)。那个哥们就走进了厕所,关上了门。