CountDownLatch的简单应用和实现原理

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就能够灵活控制阻塞线程的执行时机，耗时可以更少。

本文标题：CountDownLatch的简单应用和实现原理
当前URL：https://www.cdcxhl.com/article38/ipiosp.html

成都网站建设公司_创新互联，为您提供小程序开发、定制网站、标签优化、Google、全网营销推广、用户体验

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联