CountDownLatch的简单应用和实现原理

最新推荐文章于 2024-03-07 20:43:12 发布

绅士jiejie

最新推荐文章于 2024-03-07 20:43:12 发布

阅读量514

点赞数 2

分类专栏： # Java并发编程文章标签： CountDownLatch 并发编程多线程 java

本文链接：https://blog.csdn.net/weixin_38106322/article/details/103743113

版权

Java并发编程专栏收录该内容

179 篇文章 4 订阅

订阅专栏

CountDownLatch的简单实现

业务背景假设：现在一个前端页面的展示需要调用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()方法:

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

绅士jiejie

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
CountDownLatch的简单应用和实现原理

CountDownLatch的简单实现业务背景假设：现在一个前端页面的展示需要调用3个外部电商平台接口的数据，所以在我们提供给前端的这个接口上，我们要调用3个外部电商接口，最后需要对所有的数据做一个整合，方便前端展示。一般情况我们都是顺序调用3个电商接口，得到数据后调用整合方法，假设每个电商接口调用时间为2秒，如下： public static void main(Strin...
复制链接

扫一扫