多线规使用方式与CountDownLatch使用

最新推荐文章于 2024-10-18 13:02:57 发布

Dog_Elder

最新推荐文章于 2024-10-18 13:02:57 发布

阅读量112

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_45167029/article/details/120492041

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文展示了如何使用Java的线程池和CountDownLatch进行多线程并行执行和同步。通过实例代码，解释了线程池的配置及其在汇总统计场景中的应用，并对比了单线程执行的效率。此外，还讨论了对于非实时性需求的优化策略，如定时任务和Redis缓存的使用，以提高数据获取速度。

摘要由CSDN通过智能技术生成

面试的我快被问吐了,我只知道实现方式但总是忘记所有这次写这个demo 实际项目中也使用过常用于汇总统计如果需要更进一步优化根据功能而定不需要实时性的可采用定时器来进行执行 ,执行结果放入redis缓存中,从redis中获取速度会更加快速

测试代码

多线程进行并行执行,汇总需要同步执行

线程采用线程池方式并行执行
使用CountDownLatch类 (线程计数器) 同步处理

public class ThreadPollUtil {
    private static int corePoolSize = Runtime.getRuntime().availableProcessors();

    /**
     * corePoolSize 用于指定核心线程数量
     * maximumPoolSize 指定最大线程数
     * keepAliveTime和TimeUnit指定线程空闲后的最大存活时间
     */
    public static ThreadPoolExecutor executor  = new ThreadPoolExecutor(corePoolSize, corePoolSize+1, 10l, TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>(1000));

/*
    让主线程等待  CountDownLatch 任务计数器

    countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。

    是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。
*/


    public static void main(String[] args) throws InterruptedException {
        //创建一个三个子线程 初始化计数器
        Map<Object, Object> map = new HashMap<>();
        CountDownLatch countDownLatch = new CountDownLatch(3);

        Long m=1000000000L;
        long time11 = System.currentTimeMillis();
        ThreadPollUtil.executor.submit(new Runnable() {
            @Override
            public void run() {
                long time1 = System.currentTimeMillis();
                int i=0;
                for (int i1 = 0; i1 < m; i1++) {
                    i=i1+i;
                }
                map.put("1",i);
                //计数器-1
                countDownLatch.countDown();

                long time2 = System.currentTimeMillis();
                System.out.println("线程一"+(time1 - time2) + "毫秒。");
            }
        });
        ThreadPollUtil.executor.submit(new Runnable() {
            @Override
            public void run() {
                long time1 = System.currentTimeMillis();
                int i=0;

                for (int i1 = 0; i1 < m; i1++) {
                    i=i1+i;
                }
                map.put("1",i);
                //计数器-1
                countDownLatch.countDown();

                long time2 = System.currentTimeMillis();
                System.out.println("线程二"+(time1 - time2) + "毫秒。");
            }
        });
        ThreadPollUtil.executor.submit(new Runnable() {
            @Override
            public void run() {
                long time1 = System.currentTimeMillis();
                int i=0;
                for (int i1 = 0; i1 < m; i1++) {
                    i=i1+i;
                }
                map.put("1",i);
                //计数器-1
                countDownLatch.countDown();

                long time2 = System.currentTimeMillis();
                System.out.println("线程三"+(time1 - time2) + "毫秒。");
            }
        });

        /**
         * 通过await方法让主线程等待
         */
        countDownLatch.await();
        long time22 = System.currentTimeMillis();
        System.out.println("总线程"+(time11 - time22) + "毫秒。");

    }
}

再做个比较没有使用多线程的自上而下的逻辑

class Xxx{
    public static void main(String[] args) throws InterruptedException {
        

                long time1 = System.currentTimeMillis();
                int i=0;
                Long m=1000000000L;
                for (int i1 = 0; i1 < m; i1++) {
                    i=i1+i;
                }
        System.out.println("执行一");
                for (int i1 = 0; i1 < m; i1++) {
                    i=i1+i;
                }
        System.out.println("执行二");
                for (int i1 = 0; i1 < m; i1++) {
                    i=i1+i;
                }
        System.out.println("执行三");
        long time2 = System.currentTimeMillis();
        System.out.println("总线程"+(time1 - time2) + "毫秒。");

    }

}