AQS-等待队列
AQS的原理在于,每当有新的线程请求资源时,该线程会进入一个等待队列(Waiter Queue),只有当持有锁的线程释放资源后,该线程才能持有资源。该等待队列的实现方式是双向链表,线程会被包裹在链表节点Node中。Node即队列的节点对象,它封装了各种等待状态(典型的状态机模式),前驱和后继节点信息,以及它对应的线程。
AQS定义两种资源共享方式:Exclusive(独占,在特定时间内,只有一个线程能够执行,如ReentrantLock)和share(共享,多个线程可以同时执行,如ReadLock、Semaphore、CountDownLatch),可见不同的实现方式征用共享资源的方式不同,由此,自定义同步器在实现时要根据需求来实现共享资源state的获取与释放方式即可,至于具体线程等待队列的维护(如获取资源失败入队/唤醒出队等),AQS已经实现好了。
Node节点
1 //标记节点为共享模式
2 static final Node SHARED = new Node();
3 //标记节点为独占模式
4 static final Node EXCLUSIVE = null;
5 //等待状态
6 volatile int waitStatus;
7 //前驱结点
8 volatile Node prev;
9 //后继节点
10 volatile Node next;
11 //线程
12 volatile Thread thread;
自定义同步器时主要需要实现以下几种方法:
- isHeldExclusively():该线程是否正在独占资源,只有用到condition时才需要去使用它。
- tryAcquire(int):独占方式,尝试获取资源,返回boolean。
- tryRelease(int):独占方式,尝试释放资源,返回boolean。
- tryAcquireShared(int):共享方式,尝试获取资源,返回int。
- tryReleaseShared(int):共享方式,尝试释放资源,返回boolean。
等待队列节点对象Node有四种不同的状态:
- CANCELLED(1)已取消
- SIGNAL(-1)竞争获胜需要唤醒
- CONDITION(-2)在condition队列中等待
- PROPAGATE(-3)后续节点传播唤醒操作,共享模式下使用
acquire方法执行流程
1 public final void acquire(int arg) {
2 if(!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
3 selfInterrupt();
4 }
5 }
1) 尝试获取锁tryAcquire,返回值表示当前线程是否获取锁。
2) 如果获取成功,那么说明当前对象已经持有锁,执行中断操作,中断操作会解除线程阻塞。
3) 如果获取失败,那么把当前线程封装为Waiter节点,等待队列没有节点时初始化队列,有则使用compareAndSetTail()添加进Waiter队列尾端。
4) acquiredQueue自旋获取资源,并且返回Waiter节点持有的线程的应当具备的中断状态。
5) 根据返回结果来确定是否需要执行线程中断操作。
1 private Node addWaiter(Node mode) {
2 //封装当前节点为node节点
3 Node node = new Node(Thread.currentThread(), mode);
4 Node pred = tail;
5 if(pred != null) {
6 //将node节点的前驱节点设置为tail
7 node.prev = pred;
8 //多线程环境下,tail可能已经被其它线程修改了,这里校验pred是否依然是为节点
9 //如果是,那么将node设置为尾结点,原尾结点的后继节点设置为node,返回node
10 if(compareAndSelfTail(pred, node)) {
11 pred.next = node;
12 return node;
13 }
14 }
15 //执行到这里,说明tail为null,或者tail已经发生了变动
16 enq(node);
17 return node;
18 }
1 private Node enq(final Node node) {
2 //下面这个死循环用于把node节点插入到队尾,由于多线程环境下,tail节点可能
3 //随时变动,必须不停的尝试,让下面两个操作不会被其它线程干涉。
4 //1,node.prev必须为当前尾结点
5 //2,node设置为新的尾结点
6 for(;;) {
7 Node t = tail;
8 //tail为空,也说明head为空,此时初始化队列
9 if(t == null) {
10 //CAS方式初始化队头
11 if(compareAndSetHead(new Node()))
12 tail = head;
13 } else {
14 //设置node.prev为当前尾结点
15 node.prev = t;
16 //多线程环境下,此时尾结点可能已经被其它访问修改了,需要CAS来进行比较
17 //如果t依然是尾结点,那么node设置为尾结点、
18 if(compareAndSetTail(t, node)) {
19 t.next = node;
20 return t;
21 }
22 }
23 }
24 }
acquiredQueued(Node)方法会接收addWaiter封装好的Node对象,该方法的本质在于以自旋的方式获取资源,即自旋锁。它做了两件事,如果指定节点的前驱节点时头结点,那么再次尝试获取锁,反之,尝试阻塞当前线程。自旋不能构成死循环,否则会浪费大量CPU资源,在AQS中如果p==head&&tryAcquire(arg)条件不足时不会一直循环下去。通常,在p==head之前,必然会有一个线程得到锁,此时tryAcquire()通过,循环结束。如果发生了极端情况,那么node.predecessor()也会在node==head的情况下抛出空指针异常,循环结束。shouldParkAfterFailedAcquire(p,node)检测前驱节点的等待状态,需要阻塞则调用partAndCheckInterrupt()方法会阻塞当前线程,该循环也不会无限制的消耗资源。
1 final boolean acquireQueued(final Node, int arg) {
2 boolean failed = true;
3 try {
4 boolean interrupted = false;
5 for(;;) {
6 //找到node的前驱节点,如果node已经为head,那么会抛出空指针异常
7 //空指针异常说明整个等待队列都没有能够获取锁的线程。
8 final Node p = node.predecessor();
9 //前驱节点为头结点时,当前线程尝试获取锁
10 //如果获取成功,那么node会成为新的头结点,这个过程会清空node的线程信息。
11 if(p == head && tryAcquire(arg)) {
12 setHead(node);
13 p.next = null;
14 failed = false;
15 return interrupted;
16 }
17 //当前线程不能获取锁,则说明该节点需要阻塞
18 //shouldParkAfterFailedAcquire()用于检查和设置节点阻塞状态
19 //如果为通过检查,那么说明没有阻塞,parkAndCheckInterrupt()用于阻塞当前线程。
20 if(shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
21 interrupted = true;
22 }
23 finally {
24 if(failed) cancelAcquire(node);
25 }
26 }
27 }
1 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
2 //前驱节点的等待状态
3 int ws = pred.waitStatus;
4 if(ws == Node.SIGNAL) {
5 //SIGNAL表示前驱节点需要被唤醒,此时node是一定可以安全阻塞的,所以返回true
6 return true;
7 }
8 if(ws > 0) {
9 //大于0的等待状态只有CANCELLED,从队列里移除所有前置的CANCELLED节点。
10 do {
11 node.prev = pred = pred.prev;
12 } while (pred.waitStatus > 0);
13 pred.next = node;
14 } else {
15 //运行到这里,说明前驱节点处于0、CONDITION或者PROPAGATE状态下
16 //此时该节点需要被置为SIGNAL状态,等待被唤醒。
17 compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
18 }
19 }
1 private final boolean parkAndCheckInterrupt() {
2 //LockSupport.park()用于阻塞当前线程
3 LockSupport.park(this);
4 return Thread.interruupted();
5 }
由此可以得出结论,当一个新的线程节点入队之后,会检查它的前驱节点,只要有一个节点的状态是SIGNAL,就表示当前节点之前的节点正在被等待唤醒,那么当前线程就需要被阻塞,以等待RentrantLock.unlock()唤醒之前的线程。
在过程2中,node1刚刚入队,没有争抢到锁,此时head状态为初始化的0状态,于是调用了compareAndSetWaitStatus(pred,ws,Node.SIGNAL),这个方法会把head的状态改为SIGNAL。
在过程3中,acquired()方法里的for循环会在执行一次,此时,node1的前驱节点依然是head,如果它依然没有竞争锁,那么由于head的waitStatus属性的值为SIGNAL,这会导致shouldParkAfterFailedAcquire()方法返回true,当前线程(node1持有的线程)被阻塞,代码不在继续往下执行。这样就达到了让等待队列里的线程阻塞的目的,由此可以类推更多线程入队的过程。由此可以类推更多线程入队的过程:
SIGNAL状态由release()方法进行修改,这个方法首先调用tryRelease()方法尝试释放锁,它返回的是锁是否处于可用状态,如果锁可用,那么该方法也不负责中断等待线程的阻塞,它仅仅把锁的线程持有者设为null;然后,如果成功的释放锁,那么判断队头状态,队头为空则说明队列没有等待线程,不再做其它操作,反之再判断队头的状态waitStatus,只要它不为0,就说明等待队列中有被阻塞的节点。
1 public final boolean release(int arg) {
2 if(tryRelease(arg)) {
3 Node h = head;
4 if(h != null && h.waitStatus != 0) {
5 unparkSuccessor(h);
6 }
7 return true;
8 }
9 return false;
10 }
1 private void unparkSuccessor(Node node) {
2 int ws = node.waitStatus;
3 //小于0的状态waitStatus只有SIGNAL和CONDITION
4 if(ws < 0) {
5 compareAndSetWaitStatus(node, ws, 0);
6 }
7 Node s = node.next;
8 //前驱查找需要唤醒的节点
9 if(s == null || s.waitStatus > 0) {
10 s = null;
11 for(Node t = tail; t != null && t != node; t = t.prev) {
12 if(t.waitStatus <= 0) s = t;
13 }
14 }
15 if(s != null) {
16 LockSupport.unpark(s.thread);
17 }
18 }
unparkSuccessor()负责确保中断正确的线程阻塞。在ReentrantLock.unlock()的调用过程中,unparkSuccessor(Node node)的形参node始终为head节点,这个方法执行的主要操作为:
- 首先把head节点的waitStatus设置为0,表示队列里没有需要中断阻塞的线程。
- 然后确定需要被唤醒的节点,该节点是队列中第一个waitStatus小于等于0的节点。
- 最后,调用LockSupport.unlock()方法中断指定线程的阻塞状态。
需要注意的是,node1对应的线程此时已经中断了阻塞,它会开始继续执行AQS的AacquireQueued()方法中for循环的代码final Node p = node.predecessor();显然node1的前驱节点head由于锁已经被释放,队列变化为
这部分代码比较巧妙,可以注意到,在释放的过程中,代码里并没有改变head的waitStatus为SIGNAL,而是直接使用node1替代了原先的head。换言之,原本需要修改head/node2的前驱和后置,并且把head的waitStatus修改为SIGNAL,使用当前的代码,只需要释放node1的持有线程,然后移除head节点,这样可以更快的到达队列规整的目的。
AQS如何阻塞线程和中断阻塞
在acquired()方法中,当前线程尝试获取锁,如果没有获得,那么会把线程加入等待队列中,加入到队列的线程会被阻塞。
线程阻塞有三种常见的实现方式:Object.wait()、Thread.join()、或者Thread.sleep()。
中断阻塞则通过Thread.interrupt()方法来实现,这个方法会发出一个中断信号量从而导致线程抛出中断异常InterruptedException,已达到结束阻塞的目的。需要注意的是Interrupt不会中断用户循环体造成阻塞,它仅仅是抛出信号量,具体处理方式还是由用户处理。Thread.isInterrupted可以得到中断状态。
对于wait、sleep、join等会造成线程阻塞的方法,由于它们都会抛出Interrupted Exception,处理方式如下
1 try {
2 Thread.currentThread().sleep(500);
3 } catch (InterruptedException e) {
4 //中断后抛出异常,在异常捕获里可以对中断定制处理
5 }
对循环体处理方式如下表示:
1 //使用Thread.isInterrupted方法获取中断信号量
2 while(!Thread.currentThread().isInterrupted && 用户自定义条件) {
3 }