在AbstractQueuedSynchronizer详解(一)——分析ReentrantLock源码中介绍了其内部结构以及独占模式的一个例子:ReentrantLock。本篇文章介绍其共享模式的一个例子:CountDownLatch。
CountDownLatch的使用
CountDownLatch是一个工具类,用于使一个或多个线程等待另一系列线程完成操作,也就是说一些线程在另外一些完成之后才能继续执行,类似线性。
初始CountDownLatch时需要提供一个count参数,await方法将会使线程阻塞,直到这个值变为0,countDown()方法可以使count值减1,一旦到达0后,调用await阻塞的线程将会得到释放。
CountDown一般有两个用法。
一个线程等待多个线程
一个线程等待多个线程完成后再执行,比如一个不限时的考试,10个学生考试,交卷时间不同,当10个学生都交卷后,老师才认为考试结束。下面是该例子:
public class ExamDemo {
public static class Student implements Runnable {
private int num;//学号
private CountDownLatch countDownLatch;
public Student(int num, CountDownLatch countDownLatch) {
this.num = num;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
Random random = new Random();
try {
TimeUnit.SECONDS.sleep(random.nextInt(10) + 1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("学生" + num + "交卷了");
//完成工作,将count-1
countDownLatch.countDown();
}
}
public static class Teacher implements Runnable {
private CountDownLatch countDownLatch;
public Teacher(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
System.out.println("考试开始,不限时间!");
try {
//等待count变为0
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("考试结束");
}
}
public static void main(String[] args) {
Executor executor = Executors.newCachedThreadPool();
CountDownLatch countDownLatch = new CountDownLatch(10);
executor.execute(new Teacher(countDownLatch));
for (int i = 1; i <= 10; i++)
executor.execute(new Student(i, countDownLatch));
}
}
多个线程等待一个线程
再举个例子,比如几个司机在等红灯,而一旦变成了绿灯,几个司机就可以都通过了。
public class TrafficDemo {
public static class Driver implements Runnable {
private int num;
private CountDownLatch countDownLatch;
public Driver(int num, CountDownLatch countDownLatch) {
this.num = num;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
System.out.println("司机" + num + "于红灯前等待");
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("司机" + num + "于绿灯通过");
}
}
public static class TrafficLight implements Runnable {
private CountDownLatch countDownLatch;
public TrafficLight(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("绿灯行");
countDownLatch.countDown();
}
}
public static void main(String[] args) {
Executor executor = Executors.newCachedThreadPool();
CountDownLatch countDownLatch = new CountDownLatch(1);
for (int i = 1; i < 10; i++)
executor.execute(new Driver(i, countDownLatch));
executor.execute(new TrafficLight(countDownLatch));
}
}
CountDownLatch源码解析
CountDownLatch初始化
CountDownLatch只有一个构造方法,如下:
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
我们很容易知道Sync是一个继承自AQS的内部类,它负责CountDownLatch的同步事件。下面是Sync的定义:
/**
* Synchronization control For CountDownLatch.
* Uses AQS state to represent count.
*/
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
//AQS的资源即设定的count
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
await方法
await方法用于将线程阻塞,实现如下:
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
可以看到调用了acquireSharedInterruptibly方法,该方法在AQS中,实现如下:
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//线程被interrupt了,抛出异常
if (Thread.interrupted())
throw new InterruptedException();
//尝试获取arg个资源,如果小于0表示获取失败
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
从上面的方法可以看到,首先尝试获取资源,如果有资源,那么调用doAcquireSharedInterruptibly方法,tryAcquireShared方法是在Sync中的。从上面可以看到,如果getState为0则该线程不需要加入到等待队列中,而如果不等于0,则需要将该线程加入到等待队里中。
如果该线程需要加入到等待队列中,那么就调用doAcquireSharedInterruptibly方法,如下:
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
//将该线程加入到等待队列中
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
//得到前驱节点
final Node p = node.predecessor();
//如果前驱节点是头节点
if (p == head) {
//尝试获取资源
int r = tryAcquireShared(arg);
//getState为0,说明count为0了,等待的线程可以执行了
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
//检查是否需要将当前线程挂起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
在前一篇文章中,我们知道队列的结构如下:
其中Head是个空节点,所以一旦前驱节点是头节点,并且要是count变为了0,那么就调用setHeadAndPropagate方法,然后释放头节点。setHeadAndPropagate方法主要完成两件事,第一更改头节点,第二由于此时等待线程可以执行了,将该事件传播给后面的节点,实现如下:
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
//更改头节点
setHead(node);
/*
* Try to signal next queued node if:
* Propagation was indicated by caller,
* or was recorded (as h.waitStatus either before
* or after setHead) by a previous operation
* (note: this uses sign-check of waitStatus because
* PROPAGATE status may transition to SIGNAL.)
* and
* The next node is waiting in shared mode,
* or we don't know, because it appears null
*
* The conservatism in both of these checks may cause
* unnecessary wake-ups, but only when there are multiple
* racing acquires/releases, so most need signals now or soon
* anyway.
*/
//如果需要传播
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}
可以看到如果需要传播的话,将会调用doReleasShared方法,方法如下:
private void doReleaseShared() {
for (;;) {
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;
}
}
至此,await方法就使线程挂起了,下面再分析countDown方法。
countDown方法
countDown方法用于将count值减1,如果count变为0则释放所有等待线程,方法的实现如下:
public void countDown() {
sync.releaseShared(1);
}
releaseShared方法如下:
public final boolean releaseShared(int arg) {
//尝试释放共享资源,如果需要释放节点,则释放节点
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
tryReleaseShared需要在子类中实现,Sync中的实现如下:
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
一开始设置了count,每次countDown会使AQS的state-1,一旦变成0,则返回true。而如果变成了0后,又调用countDown则无效。doReleaseShared方法用于释放节点,这个在上面已经介绍了。
总结
CountDownLatch中使用了AQS,AQS的资源就是CountDownLatch的初始容量设置,即限定放行的线程数,采用了AQS的共享模式。
与CycilBarrier的区别在于CountDownLatch在state为0后放行的线程只会执行一次,而CycliBarrier放行后的线程可以多次执行。