forkjoin并行框架实践

最新推荐文章于 2025-01-30 19:07:50 发布

qq_20009015

最新推荐文章于 2025-01-30 19:07:50 发布

阅读量325

点赞数

CC 4.0 BY-SA版权

分类专栏：学习 java

阿里巴巴盒马大量招聘 hc多多提供全程面试辅导简历砸过来 laixiaoxing.lxx@alibaba-inc.com 5年内的p6 7年以上的p7 机会多多

本文链接：https://blog.youkuaiyun.com/qq_20009015/article/details/89913091

java 同时被 2 个专栏收录

70 篇文章

订阅专栏

学习

14 篇文章

订阅专栏

博客指出，查询SQL时发起请求后需等待数据库返回，属IO密集型操作，线程数可粗略设为2*N（N为CPU核心数）或（总时间/cpu时间）*N；对于CPU密集型任务，线程数设置为N+1即可，过多会因上下文切换浪费时间。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

 @Override
    public List<TaxForeDTO> getTaxForeForkJoin(List<String> organizeId, String uid, Date Begin, Date end)
            throws Exception {
        Long begintime=System.currentTimeMillis();
        //cpu+io总耗时23秒 io时间21秒
        //最佳线程数目 = （线程等待时间与线程CPU时间之比 + 1）* CPU数目
        //21/2+1
        int nums= 11*Runtime.getRuntime().availableProcessors();
        log.info("线程数{}",organizeId.size());
      //  ForkJoinPool forkjoinPool = new ForkJoinPool(nums);
        ForkJoinPool forkjoinPool = new ForkJoinPool(organizeId.size());
        //生成一个计算任务
        ForkJoinTaskExample task = new ForkJoinTaskExample(organizeId, uid,Begin,end);

        //执行一个任务
        Future<List<TaxForeDTO>> result = forkjoinPool.submit(task);

        List<TaxForeDTO> list=new ArrayList<>();
        try {
            list=result.get();
            log.info("result:{}", list);
        } catch (Exception e) {
            log.error("exception", e);
        }

        Long endtime=System.currentTimeMillis();
        log.info("预测表并行开始时间{},结束时间{},总耗时{},秒数{}", begintime,endtime, endtime-begintime,(endtime-begintime)/1000.0f);
        return list;
    }

     class ForkJoinTaskExample extends RecursiveTask<List<TaxForeDTO>> {

        public  final int threshold = 2;

        private List<String> organizeId;
        private String uid;
        private  Date Begin;
        private Date endDate;
        private int start;
        private int end;

        public ForkJoinTaskExample(List<String> organizeId, String uid, Date begin, Date end) {
            this.organizeId = organizeId;
            this.uid = uid;
            this.Begin = begin;
            this.endDate = end;
            this.start=0;
            this.end=organizeId.size()-1;

        }

        @Override
        protected List<TaxForeDTO> compute() {
            List<TaxForeDTO> sum=new ArrayList<>();
            //如果任务足够小就计算任务
            boolean canCompute = (end - start) <=threshold;
            if (canCompute) {
                try {
                    sum.addAll(getTaxFore(organizeId.subList(start,end),uid,Begin,endDate));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                // 如果任务大于阈值，就分裂成两个子任务计算
                int middle = (start + end) / 2;
                ForkJoinTaskExample leftTask = new ForkJoinTaskExample(organizeId.subList(start,middle),uid,Begin,endDate);
                ForkJoinTaskExample rightTask = new ForkJoinTaskExample(organizeId.subList(middle+1,end),uid,Begin,endDate);

                // 执行子任务
                leftTask.fork();
                rightTask.fork();

                // 等待任务执行结束合并其结果
                List<TaxForeDTO>  leftResult = leftTask.join();
                List<TaxForeDTO>  rightResult = rightTask.join();

                // 合并子任务
                sum.addAll(leftResult);
                sum.addAll(rightResult);
            }
            return sum;
        }
    }

这里注意下，想查询sql这种，因为发起请求之后要等待数据库的返回，大部分时间其实是在等待io。这种频繁等待io的操作是io密集型，这个时候设置的线程数
可以粗略的设置成2*N （N为cpu核心数可以用Runtime.getRuntime().availableProcessors() 获取），或者设置成（总时间/cpu时间）*N 总时间是指cpu时间+等待io时间

如果是cpu密集型任务，则线程数设置为N+1就差不多了，再多也会因为上下文切换而浪费时间，而且 cpu也不堪重负。