甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
CountDownLatch的简单实现
创新互联从2013年创立，我们提供高端网站建设、重庆小程序开发公司、电商视觉设计、重庆APP开发公司及网络营销搜索优化服务，在传统互联网与移动互联网发展的背景下，我们坚守着用标准的设计方案与技术开发实力作基础，以企业及品牌的互联网商业目标为核心，为客户打造具商业价值与用户体验的互联网+产品。
业务背景假设：现在一个前端页面的展示需要调用3个外部电商平台接口的数据，所以在我们提供给前端的这个接口上，我们要调用3个外部电商接口，最后需要对所有的数据做一个整合，方便前端展示。
一般情况我们都是顺序调用3个电商接口，得到数据后调用整合方法，假设每个电商接口调用时间为2秒，如下：
public static void main(String[] args) throws Exception{
long startTime = new Date().getTime();
//调用第一个电商平台的接口取得订单数，用时2s
Thread.sleep(2000);
System.out.println("获取电商平台1的数据");
//调用第二个电商平台的接口取得订单数，用时2s
Thread.sleep(2000);
System.out.println("获取电商平台2的数据");
//调用第三个电商平台的接口取得订单数，用时2s
Thread.sleep(2000);
System.out.println("获取电商平台3的数据");
System.out.println("对三个电商平台的数据进行合并");
long endTime = new Date().getTime();
long time = endTime - startTime;
System.out.println("总耗时" + time);
}
调用后耗时6s,如下：
以上方法耗时太长了,需要优化,优化思路：因为3个接口没有先后关系，所以完全可以并行执行，之后再做数据的整合，这样设计接口耗时肯定会节省很多
使用CountDownLatch来实现以上优化思路
CountDownLatch是什么：CountDownLatch是java.util.concurrent包下的类，它在多线程并发编程里充当这计数器的功能，通过构造函数维护一个int类型的初始值，如果一个线程调用await()方法，那么该线程就会进入阻塞状态，直到初始值变为0后，调用await()方法的阻塞线程将会被唤醒，执行后续操作，而通过countDown()这个方法，我们就能够实现初始值的减法，每调用一次，初始值减一。
具体实现代码如下：
public static void main(String[] args) throws Exception {
CountDownLatch countDownLatch = new CountDownLatch(3);
long startTime = new Date().getTime();
//调用第一个电商平台的接口取得订单数，用时2s
Thread thread1 = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台一的数据");
countDownLatch.countDown();
});
//调用第二个电商平台的接口取得订单数，用时2s
Thread thread2 = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台二的数据");
countDownLatch.countDown();
});
//调用第二个电商平台的接口取得订单数，用时2s
Thread thread3 = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台三的数据");
countDownLatch.countDown();
});
thread1.start();
thread2.start();
thread3.start();
countDownLatch.await();
System.out.println("对三个电商平台的数据进行合并");
long endTime = new Date().getTime();
long time = endTime - startTime;
System.out.println("总耗时" + time);
}
因为电商接口有3个，所以CountDownLatch的初始值设为3，之后多线程执行3个电商接口，每执行完一个，调用countDown()方法把初始值减一，同时主线程调用await()进入阻塞状态，直到初始值减为0，就被重新唤醒，开始执行数据的合并逻辑。
执行效果如下：
可以看到总耗时节省了约三分之二
CountDownLatch的实现原理
先看CountDownLatch的构造方法：
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
可以看到它除了做个初始值的异常判断外，实际上是构造了一个Sync的对象，赋值给自己的属性sync，那么看下Sync对象的源码：
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
//Sync对象的构造方法
Sync(int count) {
setState(count);
}
}
从以上源码可以看出，Sync对象继承了AQS,所以调用CountDownLatch的构造方法实际上就是调用Sync对象的构造方法，然后通过setState(count)方法设置AQS的state值。
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
private volatile int state;
protected final void setState(int newState) {
state = newState;
}
}
再看countDown()方法的实现：
public void countDown() {
sync.releaseShared(1);
}
实际上是调用了Sync对象的releaseShared()方法，参数固定为1
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
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 (;;) {
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()的具体实现是在CountDownLatch类，如下：
public class CountDownLatch {
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;
}
}
}
//获取计数器的值
protected final int getState() {
return state;
}
}
通过循环和compareAndSetState()方法我们可以看出这是一个自旋的CAS(Compare And Set)操作，先获取state的值，为0则返回false，否则执行减1操作，失败就重试，直到减为0，则返回true，之后执行doReleaseShared()方法
await()方法的实现
public class CountDownLatch {
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
}
可以看到await()实际是调用Sync对象的acquireSharedInterruptibly()方法：
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
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);
}
}
}
其中tryAcquireShared()方法的具体实现是在CountDownLatch类:
public class CountDownLatch {
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
}
通过该方法可以判断出如果计数器值为0则返回1，否则返回-1，然后为0则会执行之后的方法，如果继续跟下去，最后会发现还是调用到了AQS的doReleaseShared()方法,所有阻塞的线程会被放开。
CountDownLatch和.join()的使用区别
CountDownLatch和.join()方法的作用其实很像，join()方法的使用可参考Java多线程中join()方法的使用，不过CountDownLatch使用起来会比join()方法更有灵活性。假设电商接口调用其实有两个步骤，在每个接口的第一步获取完数据后，还要做个数据记录，耗时也是2s，下面给出示例代码：
使用join()方法:郑州人流多少钱 http://mobile.sgyy029.com/
public static void main(String[] args) throws Exception {
CountDownLatch countDownLatch = new CountDownLatch(3);
long startTime = new Date().getTime();
//调用第一个电商平台的接口取得订单数，用时2s
Thread thread1 = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台一的数据");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台一的数据后做个记录");
});
//调用第二个电商平台的接口取得订单数，用时2s
Thread thread2 = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台二的数据");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台二的数据后做个记录");
});
//调用第三个电商平台的接口取得订单数，用时2s
Thread thread3 = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台三的数据");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台三的数据后做个记录");
});
thread1.start();
thread2.start();
thread3.start();
thread1.join();
thread2.join();
thread3.join();
System.out.println("对三个电商平台的数据进行合并");
long endTime = new Date().getTime();
long time = endTime - startTime;
System.out.println("总耗时" + time);
}
耗时效果如下:
可以发现，使用join()方法，必须得等到每个线程都结束后才会接着执行之后的主线程，这样总耗时就会被数据记录的方法拖慢，达到4311ms
使用CountDownLatch，在获取数据后就对初始值减1，而不是等到记录方法完成才减1，如下：
public static void main(String[] args) throws Exception {
CountDownLatch countDownLatch = new CountDownLatch(3);
long startTime = new Date().getTime();
//调用第一个电商平台的接口取得订单数，用时2s
Thread thread1 = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台一的数据");
countDownLatch.countDown();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台一的数据后做个记录");
});
//调用第二个电商平台的接口取得订单数，用时2s
Thread thread2 = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台二的数据");
countDownLatch.countDown();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台二的数据后做个记录");
});
//调用第二个电商平台的接口取得订单数，用时2s
Thread thread3 = new Thread(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台三的数据");
countDownLatch.countDown();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("获取电商平台三的数据后做个记录");
});
thread1.start();
thread2.start();
thread3.start();
countDownLatch.await();
System.out.println("对三个电商平台的数据进行合并");
long endTime = new Date().getTime();
long time = endTime - startTime;
System.out.println("总耗时" + time);
}
耗时效果如下:
可以发现耗时才2185ms
以上就是CountDownLatch和join()方法的使用区别，相比起join()方法要等线程都执行完才会执行阻塞的线程，CountDownLatch就能够灵活控制阻塞线程的执行时机，耗时可以更少。