概述
前段时间在解决请求风控服务器超时的问题时，涉及到到一个CountDownLunch的并发工具类,非常实用，顺记自然就去研究了一下相关的并发工具类。
在JDK的并发包里(java.util.concurrent)提供了这样几个非常有用的并发工具类来解决并发编程的流程控制。分别是CountDownLatch、CyclicBarrier和Semaphore。
1. CountDownLatch
1.1 CountDownLatch是什么?
CountDownLatch打多是被用在等待多线程完成，具体来说就是允许一个或多个线程等待其他线程完成操作。
1.2 CountDownLatch原理？
API 文档有这样一盒解释
A CountDownLatch is a versatile synchronization tool and can be used for a number of purposes. A CountDownLatch initialized with a count of one serves as a simple on/off latch, or gate: all threads invoking await wait at the gate until it is opened by a thread invoking countDown(). A CountDownLatch initialized to N can be used to make one thread wait until N threads have completed some action, or some action has been completed N times.
构造函数
//Constructs a CountDownLatch initialized with the given count.
public void CountDownLatch(int count) {...}
在 CountDownLunch启动的时候。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。
public void countDown()
在每次任务执行完直接调用，计数器就会减一操作。
public boolean await(long timeout,TimeUnit unit) throws InterruptedException
public void await() throws InterruptedException
这个方法就是用来堵塞主线程的，前者是有等待时间的，可以自定义，后者是无限等待，知道其他count 计数器为0为止。
详细的 demo 就不在这里粘贴了
如有需要传送门
1.3 使用场景
超时机制
主线程里面设置好等待时间，如果发现在规定时间内还是没有返回结果，那就唤醒主线程，抛弃。
开始执行前等待n个线程完成各自任务
例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。
死锁检测
一个非常方便的使用场景是，你可以使用n个线程访问共享资源，在每次测试阶段的线程数目是不同的，并尝试产生死锁。
若有不正之处请多多谅解，并欢迎各位大牛批评指正。
1.4 深入源码
这里面我简单的研究了一下CountDownLunch 源码。
底层是由AbstractQueuedSynchronizer提供支持(后面就简称 AQS)，所以其数据结构就是AQS的数据结构，而AQS的核心就是两个虚拟队列：同步队列syncQueue 和条件队列conditionQueue(前者数据结构是双向链表，后者是单向链表)不同的条件会有不同的条件队列。
本省CountDownLunch继承的是 Object，比较简单，但是存在内部类，Sync，继承自AbstractQueuedSynchronizer,我简单理解一下
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;
}
}
}
1.4.1核心函数分析
- await函数
此函数将会使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。其源码如下
public void await() throws InterruptedException{
// 转发到sync对象上
sync.acquireSharedInterruptibly(1);
}
源码可知，对CountDownLatch对象的await的调用会转发为对Sync的acquireSharedInterruptibly（从AQS继承的方法）方法的调用。
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
这里先检测了线程中断状态，中断了则抛出异常，接下来调用tryAcquireShared，tryAcquireShared是Syn的实现的
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
其实就是简单的获取了同步器的state，判断是否为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);
}
}
关键点 我看到的是
parkAndCheckInterrupt（）
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
执行到此处时，线程会阻塞，知道有其他线程唤醒此线程，执行await之后，上文中的主线程阻塞在这。
- countDown函数
此函数将递减锁存器的计数，如果计数到达零，则释放所有等待的线程
void countDown() {
sync.releaseShared(1);
}
可以看出 对countDown的调用转换为对Sync对象的releaseShared（从AQS继承而来）方法的调用。
这里面的具体原理能力有限，有点看不懂，CAS相关的东西。
1.5 小结
不得不说countdownlatch是一个很高的线程控制工具，极大的方便了我们开发。由于知识能力有限，上面是自己的一点见识，有什么错误还望提出，便于我及时改进。
