• Java中的countDownLatch


    1.背景:

    • countDownLatch是在java1.5被引入,跟它一起被引入的工具类还有CyclicBarrier、Semaphore、concurrentHashMap和BlockingQueue。
    • 存在于java.util.cucurrent包下

    2.概念

    • countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行
    • 是通过一个计数器来实现的,计数器的初始值是线程的数量。每当一个线程执行完毕后,计数器的值就-1,当计数器的值为0时,表示所有线程都执行完毕,然后在闭锁上等待的线程就可以恢复工作了。

    3.源码

    • countDownLatch类中只提供了一个构造器:
    //参数count为计数值
    public CountDownLatch(int count) {  };  
    • 类中有三个方法是最重要的:
    //调用await()方法的线程会被挂起,它会等待直到count值为0才继续执行
    public void await() throws InterruptedException { };   
    //和await()类似,只不过等待一定的时间后count值还没变为0的话就会继续执行
    public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
    //将count值减1
    public void countDown() { };  

    4.示例

    普通示例:
    public class CountDownLatchTest {
    
        public static void main(String[] args) {
            final CountDownLatch latch = new CountDownLatch(2);
            System.out.println("主线程开始执行…… ……");
            //第一个子线程执行
            ExecutorService es1 = Executors.newSingleThreadExecutor();
            es1.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        System.out.println("子线程:"+Thread.currentThread().getName()+"执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    latch.countDown();
                }
            });
            es1.shutdown();
    
            //第二个子线程执行
            ExecutorService es2 = Executors.newSingleThreadExecutor();
            es2.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("子线程:"+Thread.currentThread().getName()+"执行");
                    latch.countDown();
                }
            });
            es2.shutdown();
            System.out.println("等待两个线程执行完毕…… ……");
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("两个子线程都执行完毕,继续执行主线程");
        }
    }

    结果集:

    主线程开始执行…… ……
    等待两个线程执行完毕…… ……
    子线程:pool-1-thread-1执行
    子线程:pool-2-thread-1执行
    两个子线程都执行完毕,继续执行主线程

    模拟并发示例:

    public class Parallellimit {
        public static void main(String[] args) {
            ExecutorService pool = Executors.newCachedThreadPool();
            CountDownLatch cdl = new CountDownLatch(100);
            for (int i = 0; i < 100; i++) {
                CountRunnable runnable = new CountRunnable(cdl);
                pool.execute(runnable);
            }
        }
    }
    
     class CountRunnable implements Runnable {
        private CountDownLatch countDownLatch;
        public CountRunnable(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }
        @Override
        public void run() {
            try {
                synchronized (countDownLatch) {
                    /*** 每次减少一个容量*/
                    countDownLatch.countDown();
                    System.out.println("thread name:"+Thread.currentThread().getName()+",thread counts = " + (countDownLatch.getCount()));
                }
                countDownLatch.await();
                System.out.println("thread name:"+Thread.currentThread().getName()+",concurrency counts = " + (100 - countDownLatch.getCount()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    结果集:

    thread name:pool-1-thread-1,thread counts = 99
    thread name:pool-1-thread-5,thread counts = 98
    thread name:pool-1-thread-4,thread counts = 97
    thread name:pool-1-thread-6,thread counts = 96
    thread name:pool-1-thread-3,thread counts = 95
    thread name:pool-1-thread-7,thread counts = 94
    thread name:pool-1-thread-2,thread counts = 93
    thread name:pool-1-thread-8,thread counts = 92
    thread name:pool-1-thread-9,thread counts = 91
    thread name:pool-1-thread-10,thread counts = 90
    thread name:pool-1-thread-11,thread counts = 89
    thread name:pool-1-thread-12,thread counts = 88
    thread name:pool-1-thread-13,thread counts = 87
    ...
    thread name:pool-1-thread-98,thread counts = 2
    thread name:pool-1-thread-99,thread counts = 1
    thread name:pool-1-thread-100,thread counts = 0
    thread name:pool-1-thread-100,concurrency counts = 100
    thread name:pool-1-thread-1,concurrency counts = 100
    thread name:pool-1-thread-4,concurrency counts = 100
    thread name:pool-1-thread-5,concurrency counts = 100
    ...

    CountDownLatch和CyclicBarrier区别:

    1.countDownLatch是一个计数器,线程完成一个记录一个,计数器递减,只能只用一次
    2.CyclicBarrier的计数器更像一个阀门,需要所有线程都到达,然后继续执行,计数器递增,提供reset功能,可以多次使用

    https://www.jianshu.com/p/e233bb37d2e6

  • 相关阅读:
    [方法] 如何做产品功能设计
    js如何去除一个数组中与另一个数组中的值相同的元素
    js 导出Excel2
    js 导出Excel
    CSS3动画
    没有欲望是一种什么样的感觉
    L9-DOM高级应用
    L8-DOM操作应用
    L7-DOM基础
    L6-js定时器的应用
  • 原文地址:https://www.cnblogs.com/Vincent-yuan/p/15004258.html
Copyright © 2020-2023  润新知