首先准备一个可以跑的Demo
private final static int threadCount = 200;
public static void main(String[] args) throws Exception {
//1、创建线程池
ExecutorService exec = Executors.newCachedThreadPool();
//2、创建CountDownLatch,并传入线程数
final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
//3、循环遍历线程
for (int i = 0; i < threadCount; i++) {
final int threadNum = i;
exec.execute(() -> {
try {
//4、执行线程
test(threadNum);
} catch (Exception e) {
log.error("exception", e);
} finally {
//5、countDownLatch计数器减少1
countDownLatch.countDown();
}
});
}
//6、等待所有线程执行完
countDownLatch.await();
log.info("finish");
//7、关闭线程池
exec.shutdown();
}
private static void test(int threadNum) throws Exception {
Thread.sleep(100);
log.info("{}", threadNum);
Thread.sleep(100);
}
我们简单的解释一下程序:开始我们为CountDownLatch设置一个threadCount值,当线程每次执行完一次,我们把countDownLatch减1,当所有的线程执行完成之后,countDownLatch的某个参数被减为0,所以程序会继续执行下去,最后关闭线程。
我们可以对CountDownLatch有一个初步的推测:
1、CountDownLatch内部一定有一个状态值用来接收传入的参数,用来定义当前所处的状态
2、CountDownLatch在调用await()的时候由于被堵塞(受状态值的影响),所以猜测内部实现应该有一个类似于while循环的代码在一直判断状态的值。
带着这些初步的猜测,让我们进入源码看看
首先我们看看构造函数
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
这里我们传入的count值是用来实例化Sync的,这个Sync被CountDownLatch包装,看看Sync
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
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;
}
}
}
这个Sync继承自AbstractQueuedSynchronizer这个关键的类(有对于AbstractQueuedSynchronizer原理不了解的可以参考其他资料,这里默认都了解)。
并且把传入的count值赋予AbstractQueuedSynchronizer的state。
Sync主要重写了两个方法:
tryAcquireShared是用于Node尝试去获取共享资源,当state等于0的时候,意味着资源可以被下一个 Node获取。
相反,tryReleaseShared是用于尝试去释放共享资源,当state等于0的时候说明当前的Node并没有持有资源,所以返回false,反之获取到共享资源的state-1之后,然后判断是否为0表示可以进行释放。
这下我们的CountDownLatch就实例化好了,过程很简单。
接下来我们直接看到第5步,对CountDownLatch进行countDown操作
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
这里很简单,首先对state进行减1的操作然后判断是否能够release,如果返回true的话就调用父类的doReleaseShared进行共享资源的释放。
这里我们最后看看第6步
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
这里是调用父类的方法,我们继续点开看看
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
首先我们调用CountDownLatch的tryAcquireShared尝试去获取资源,当我们任务没有进行完的时候这里是为-1小于0,然后走下面逻辑,我们简单看看
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);
//如果获取成功,则跳出循环,否则程序卡死在这
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);
}
}
这里证实了我们刚开始对CountDownLatch的一个猜测,我们把任务都扔进池子里之后,在任务未所有完成之前,调用await方法,方法会通过一个死循环一直卡死在tryAcquireShared这个判断里,直到我们所有线程执行完成之后走完finally把state设置为0死循环才会被跳出然后继续走主程序里的下一个操作,这样可以保证程序的有序性。