AQS(AbstractQueuedSynchronizer)是JUC框架中最重要的类，通过它来实现独占锁和共享锁。本次阅读AbstractQueuedSynchronizer从一下四部分进行解析
- CLH队列即同步队列：储存着所有等待锁的线程
- 独占锁
- 共享锁
- Condition条件
注：阅读的jdk版本为1.8
-
CLH队列（线程同步队列）
在获取锁之前，没有获取到锁的线程就要阻塞，线程同步队列就是存储阻塞线程的。
Node类
在AQS中使用CLH存储等待的线程，但并不是直接保存线程，而是通过内部类Node链表存储。首先介绍Node类 。
static final class Node {
/** 共享模式 */
static final Node SHARED = new Node();
/** 独占模式 */
static final Node EXCLUSIVE = null;
/**
* 以下四个变量表示线程的等待状态
*/
/** 表示线程取消 */
static final int CANCELLED = 1;
/** 表示下一个后继线程需要进入阻塞状态 ，独占锁时使用*/
static final int SIGNAL = -1;
/** 表示线程在Condition条件上需要阻塞 */
static final int CONDITION = -2;
/**
* 表示下一个acquireShared方法线程应该被允许，共享锁使用
*/
static final int PROPAGATE = -3;
/**
* 线程等待状态，默认为0，大于0表示线程已经取消，小于0表示有特殊状态
*/
volatile int waitStatus;
/**
* 前置节点
*/
volatile Node prev;
/**
* 后置节点
*/
volatile Node next;
/**
*该节点等待线程
*/
volatile Thread thread;
/**
*有两种作用：
* 1. 表示下一个在Condition条件上等待的节点，这种情况节点一定是共享模式
* 2. 表示是共享模式或者独占模式
*/
Node nextWaiter;
/**
* 是否是共享锁模式
*/
final boolean isShared() {
return nextWaiter == SHARED;
}
/**
* 返回前置节点prev,如果为null，则抛出空指针异常
*/
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
//无参构造函数，用于初始化头节点或者共享模式标志
Node() { // Used to establish initial head or SHARED marker
}
//在addWaiter方法共使用
Node(Thread thread, Node mode) { // Used by addWaiter
this.nextWaiter = mode;
this.thread = thread;
}
//在Condition条件中使用
Node(Thread thread, int waitStatus) { // Used by Condition
this.waitStatus = waitStatus;
this.thread = thread;
}
}其中重要的成员属性：
- waitStatus ： 当前节点线程等待状态，默认值为0，共有5个值：CANCELED，SIGNAL，CONDITION，PROPAGATE和0；
- prev和next : 前置节点和后继节点
- thread ： 当前节点存储的线程对象
- nextWaiter ： 如果是SHARED，表示当前节点是共享模式，如果是null，当前节点是独占模式，如果是其他值，当前节点也是独占模式，不过这个值也是Condition队列的下一个节点。
操作CLH队列
入列操作
/**
* Creates and enqueues node for current thread and given mode.
* 入列，添加线程等待状态，分为独占锁和共享锁两种模式
*
* @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
* @return the new node
*/
private Node addWaiter(Node mode) {
//创建当前线程节点
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
//入列,首先快速尝试插入新节点，成功直接返回，失败则通过enq方法尝试，直到成功
Node pred = tail;
if (pred != null) {
node.prev = pred;
//通过CAS设置尾节点
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//失败则通过enq方法尝试，直到成功
enq(node);
return node;
}
private final boolean compareAndSetTail(Node expect, Node update) {
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
private final boolean compareAndSetHead(Node update) {
return unsafe.compareAndSwapObject(this, headOffset, null, update);
}入列操作首先会进行快速插入操作，如果插入成功，则直接返回，在多线程情况下，有时会插入失败，此时通过enq()方法不断尝试，直到成功。
出列
private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}出列操作在首节点的线程状态释放后，将唤醒下一个节点，后继节点则会设置自己为首节点。因为只有一个线程可以成功获取到线程状态，所以此处不需要CAS操作。
-
独占锁
独占锁有两个功能：
- 获取锁。当多个线程一起获取锁时，只有一个线程可以成功，其他都阻塞等待。
- 释放锁。获取到锁的线程释放锁资源并唤醒其他线程等待状态。
-
获取锁
/**
* 首先尝试获取独占锁，如果获取成功则直接返回，如果失败，则将当前线程插入CLH中
* 如果在尝试获取锁的过程中有其他线程调用该线程的中断方法，则中断线程。
*/
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
//获取锁
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;
}
//1.判断是否当前线程是否应该进入等待状态
//2.阻塞当前线程并判断线程是否中断
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
//线程中断还未获到锁，取消获取锁
if (failed)
cancelAcquire(node);
}
}
//是否阻塞当前线程
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//前置线程的等待状态，如果时SIGNAL，表示后继节点需要阻塞。
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
return true;
if (ws > 0) {
/*
* 前置节点为取消状态，大于0即为取消状态，移除waitStatus为取消状态的前置节点。
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/**
剩余状态只能时0或者PROPAGATE，不可能时Condition状态，使用CAS将前置节点设置为SIGNAL状态，直接阻塞线程
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
//阻塞当前线程并返回当前线程是否中断
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
//取消获取锁
private void cancelAcquire(Node node) {
if (node == null)
return;
node.thread = null;
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
//线程等待状态不是取消状态的前置节点
Node predNext = pred.next;
//设置当前节点等待状态为取消
node.waitStatus = Node.CANCELLED;
//如果时尾节点，CAS移除自己，将前置节点设置为尾节点
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
// If successor needs signal, try to set pred's next-link
// so it will get one. Otherwise wake it up to propagate.
//不是尾节点添加，移除自己并设置后继节点
int ws;
//前置节点不是头节点，CAS设置前置节点的线程等待状态阻塞
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
//唤醒后继节点
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
private void unparkSuccessor(Node node) {
//当前节点状态
int ws = node.waitStatus;
//当前状态 < 0 则设置为 0
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//当前节点的后继节点
Node s = node.next;
//后继节点为null或者其状态 > 0 (超时或者被中断了)
if (s == null || s.waitStatus > 0) {
s = null;
//从tail节点来找可用节点
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
//唤醒后继节点
if (s != null)
LockSupport.unpark(s.thread);
}
获取锁的流程 :
- 通过子类tryAcquired()方法尝试获取共享锁，获取成功返回true;
- 获取失败则通过acquireQueued()方法循环尝试获取锁。
- 如果获取成功则重新设置CLH头节点。
- 获取失败判断线程是否中断，如果没有则让当前线程阻塞，继续尝试获取独占锁。
- 如果线程因异常中断，将节点状态设置为CANCALED状态，并将该线程节点移出CLH队列。
注：tryAcquire()方法由子类重写，否则会抛出异常。这个方法的作用是当前线程尝试获取锁，如果获取到锁，就会返回true，并更改锁资源。没有获取到锁返回false。这个方法是立即返回的，不会阻塞当前线程。
释放锁
//释放锁
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
//唤醒后置节点，释放锁
private void unparkSuccessor(Node node) {
//当前节点状态
int ws = node.waitStatus;
//当前状态 < 0 则设置为 0
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//当前节点的后继节点
Node s = node.next;
//后继节点为null或者其状态 > 0 (超时或者被中断了)
if (s == null || s.waitStatus > 0) {
s = null;
//从tail节点来找可用节点
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
//唤醒后继节点
if (s != null)
LockSupport.unpark(s.thread);
}释放锁流程
调用tryRelease()方法尝试释放锁，如果返回true则释放锁成功，然后调用unparkSuccessor()唤醒后继节点。
如果返回失败，说明释放锁还持有资源。
注：子类必须重写tryRelease方法，否则会抛出异常。
-
共享锁
共享锁会被多个线程占用，实现上也有不同之处。
获取锁
共享锁通过acquireShared方法尝试获取锁，源码如下。
//获取共享锁
public final void acquireShared(int arg) {
//尝试获取共享锁，
//如果获取失败，即tryAcquireShared()返回值小于0，则调用doAcquireShared获取共享锁
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
//子类必须重写该方法才能够获取共享锁，否则抛出异常
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
//尝试获取共享锁
private void doAcquireShared(int arg) {
//添加共享锁模式的节点
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
//无限循环直到获取到锁
final Node p = node.predecessor();
//如果前置节点是头节点，则尝试获取共享锁
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
//获取成功，重新设置CLH头节点
setHeadAndPropagate(node, r);
p.next = null; // help GC
//中断线程
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
//重新设置CLH头节点，并唤醒后继节点的等待线程
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
//设置头节点
setHead(node);
//唤醒后继节点线程
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}
//释放共享锁
private void doReleaseShared() {
for (;;) {
//无限循环，使用CAS唤醒头节点
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}共享锁获取的流程：
- 首先通过子类的tryAcquiredShared()方法尝试获取共享锁，获取成功返回。
- 获取失败则通过doAcquiredShared()方法再循环内尝试获取。
- 获取成功后，重新设置CLH头节点(setHeadAndPropagate()方法)。
- 在setHeadAndPropagate()方法中，除了重新设置CLH头节点，还会获取下一个节点，如果下一个节点为null或者是共享锁模式，就唤醒共享锁上的等待线程。
- 如果在尝试获取共享锁时发生了异常导致线程中断，则将该节点状态设置尾CANCALE状态，与独占锁模式相同。
注：tryAcquiredShared()必须由子类实现.
释放锁
释放锁流程源码如下：
//释放共享锁
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
//释放共享锁
private void doReleaseShared() {
for (;;) {
//无限循环，使用CAS唤醒头节点
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}释放共享锁流程：
- 首先通过子类tryReleaseShared()方法尝试释放共享锁，释放成功返回true,返回false说明还有资源未释放。
- 释放成功使用dlReleaseShared(0方法唤醒等待共享锁的线程。
-
Condition
Condition是为了实现线程间相互等待设计的。注意Conditiion对象只能在独占锁中 使用。
在AQS中Condition的实现如下：
- 首先内部存在一个Condition队列，存储所有在此Condition条件等待的线程。
- await方法方法：让当前持有锁的线程释放锁，并唤醒CLH队列上的等待锁的线程，再为当前线程创建一个node节点，插入到Condition队列中。
- signal系列方法：将Condition队列上的等待节点插入到CLH队列中，当持有锁的线程执行完毕释放锁之后，就会唤醒CLH队列中的一个线程。
ConditionObject对象
ConditionObject是AQS的一个内部类，它实现了Condition接口，await系列方法和signal方法都在该接口中定义。
Condition中的几个重要属性：
//Codition队列头
private transient Node firstWaiter;
/** Last node of condition queue. */
//队列尾
private transient Node lastWaiter;
/** Mode meaning to reinterrupt on exit from wait */
//再次中断标志。
private static final int REINTERRUPT = 1;
/** Mode meaning to throw InterruptedException on exit from wait */
//抛出异常标志。
private static final int THROW_IE = -1;Condition队列中节点状态包括三种
- -2 初始状态，为Node.CONDITION；
- 1 REINTERRUPT，需要中断线程；
- -1 THROW_IE 线程中断，抛出异常。
await方法源码如下：
public final void await() throws InterruptedException {
//线程中断，抛出异常
if (Thread.interrupted())
throw new InterruptedException();
//将当前线程加入到Condition队列中
Node node = addConditionWaiter();
//释放当前线程的锁并唤醒CLH队列的一个等待节点线程
long savedState = fullyRelease(node);
int interruptMode = 0;
//节点不在CLH队列中
while (!isOnSyncQueue(node)) {
//阻塞当前线程
LockSupport.park(this);
//如果Codition状态不为0，即发生中断 -1 ，跳出循环。
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
//尝试获取锁，并且线程没有中断。
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null) // clean up if cancelled
//移除取消的COndition节点。
unlinkCancelledWaiters();
if (interruptMode != 0)
//如果interruptMode不为0(REINTERRUPT)即为-1 （THROW_IE）,
//中断线程，抛出InterruptedException异常
reportInterruptAfterWait(interruptMode);
}
//将当前线程添加到Condition队列中
private Node addConditionWaiter() {
Node t = lastWaiter;
// If lastWaiter is cancelled, clean out.
if (t != null && t.waitStatus != Node.CONDITION) {
//移除线程状态取消的节点
unlinkCancelledWaiters();
t = lastWaiter;
}
Node node = new Node(Thread.currentThread(), Node.CONDITION);
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
lastWaiter = node;
return node;
}
//移除取消状态的节点
private void unlinkCancelledWaiters() {
Node t = firstWaiter;
Node trail = null;
while (t != null) {
Node next = t.nextWaiter;
if (t.waitStatus != Node.CONDITION) {
t.nextWaiter = null;
if (trail == null)
firstWaiter = next;
else
trail.nextWaiter = next;
if (next == null)
lastWaiter = trail;
}
else
trail = t;
t = next;
}
}
//释放当前线程锁，并唤醒CLH队列中的一个节点
final long fullyRelease(Node node) {
boolean failed = true;
try {
long savedState = getState();
if (release(savedState)) {
failed = false;
return savedState;
} else {
throw new IllegalMonitorStateException();
}
} finally {
if (failed)
node.waitStatus = Node.CANCELLED;
}
}
//释放线程，此处调用独占锁的tryRelease方法和unparkSuccessor方法，不再附加。
public final boolean release(long arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
//判断Condition是否在CLH队列中
final boolean isOnSyncQueue(Node node) {
// 如果node的状态是Node.CONDITION，或者node没有前一个节点prev，
// 那么返回false，节点node不在同步队列中
if (node.waitStatus == Node.CONDITION || node.prev == null)
return false;
// 如果node有下一个节点next，那么它一定在同步队列中
if (node.next != null) // If has successor, it must be on queue
return true;
// 在同步队列中从后向前查找节点node，如果找到返回true，否则返回false
return findNodeFromTail(node);
}
private boolean findNodeFromTail(Node node) {
Node t = tail;
for (;;) {
if (t == node)
return true;
if (t == null)
return false;
t = t.prev;
}
}
await方法的流程如下：
- 首先判断线程是否中断，如果中断则抛出异常。
- 将当前线程加入到Condition队列中；
- 释放线程锁并返回线程保存状态saveStated;
- 判断当前节点是否在CLH队列中，如果在就阻塞当前线程，如果当前线程已经中断则跳出循环；
- 尝试获取线程锁，获取成功并且线程没有中断则设置中断模式为REINTERRUPT；
- 移除取消的Condition节点。
- 如果中断模式不是REINTERRUPT，中断线程，抛出异常。
signal方法：
public final void signal() {
//不是独占锁模式，抛出异常。
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
//将Condition节点头加入CLH队列中。
doSignal(first);
}
//唤醒Condition节点，实际上就是将Condition节点加入CLH队列中
private void doSignal(Node first) {
do {
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
first.nextWaiter = null;
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
final boolean transferForSignal(Node node) {
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
//将Condition节点加入到CLH队列中
Node p = enq(node);
int ws = p.waitStatus;
//如果节点状态 取消阻塞线程
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
LockSupport.unpark(node.thread);
return true;
}signal流程：
- 如果不是独占锁模式，抛出异常
- 调用doSignal方法，将Condition节点加入到CLH队列中。
总结
使用AQS实现独占锁和共享锁。
- AQS内部维护一个线程等待队列CLH，用来记录等待锁的线程的状态
- 通过acquire方法来尝试获取独占锁，获取失败，则阻塞当前线程
- 通过release方法释放独占锁，释放成功，就唤醒下一个等待独占锁的线程
- 通过acquireShared方法尝试获取共享锁。
- 通过releaseShared方法用来释放共享锁。
- Condition内部维护一个Condition队列用于记录线程等待状态，实现线程之间相互等待。
扫一扫
356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
