• Fork/Join 框架框架使用


    1、介绍

    Fork/Join 框架是 Java7 提供了的一个用于并行执行任务的框架, 是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。在多核计算机中正确使用可以很好的发挥cpu的作用,提高程序的执行效率。框架采用工作窃取算法,当有子任务线程处理完当前任务时,它会从其他线程执行的任务队列里窃取任务来执行,从而提高整体的执行效率。为了减少线程间的任务资源竞争,队列通常使用双端队列,别窃取任务线程永远从啥UN广大UN队列的呕吐不获取任务执行,而窃取任务的线程永远从双端队列的尾部获取任务执行。

    2、使用

    根据业务场景来考虑是否需要使用Fork/Join框架来进行任务的拆分和汇总操作。当需要时,比如说需要执行一个很大的业务计算之类的,此时使用Fork/Join框架分以下两步:

    • 对任务进行分割        把大任务分割成子任务,有可能子任务还是很大,所以还需要不停的分割,直到分割出的子任务足够小
    • 执行分割的子任务并汇总结果       分割的子任务分别放在双端队列里,然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都统一放在一个队列里,启动一个线程从队列里拿数据,然后合并这些数据

    具体实现以上两步:

    1. 创建ForkJoinTask         它提供在任务中执行 fork() 和 join() 操作的机制,通常情况下我们不需要直接继承 ForkJoinTask 类,而只需要继承它的子类,Fork/Join 框架提供了以下两个子类:   RecursiveAction:用于没有返回结果的任务   RecursiveTask :用于有返回结果的任务
    2. 使用ForkJoinPool执行ForkJoinTask       任务分割出的子任务会添加到当前工作线程所维护的双端队列中,进入队列的头部。当一个工作线程的队列里暂时没有任务时,它会随机从其他工作线程的队列的尾部获取一个任务

    3、示例

    3.1 使用fork

    public class SumTask extends RecursiveTask <Integer>{
        private static final Integer THRESHOLD = 1000;
        private int start;
        private int end;
        public SumTask(int start, int end) {
            this.start = start;
            this.end = end;
        }
    
        @Override
        protected Integer compute() {
            Integer sum = 0;
            boolean isOk = (end - start) <= THRESHOLD;
            if(isOk) {
                for(int i = start; i <= end; i ++) {
                    sum += i;
                }
                return sum;
            }
    
            int middle = (end + start) / 2;
            //子任务递归
            SumTask sumSubTask = new SumTask(start, middle);
            SumTask sumSubTask1 = new SumTask(middle + 1, end);
    
            //fork子任务
            sumSubTask.fork();
            sumSubTask1.fork();
    
            //join子任务
            Integer join = sumSubTask.join();
            Integer join1 = sumSubTask1.join();
    
            sum = join + join1;
            //计算结果
            return sum;
        }
    }

    3.2 使用invokeAll

    public class SumTask2 extends RecursiveTask <Integer>{
        private static final Integer THRESHOLD = 1000;
        private int start;
        private int end;
        public SumTask2(int start, int end) {
            this.start = start;
            this.end = end;
        }
    
        @Override
        protected Integer compute() {
            Integer sum = 0;
            boolean isOk = end - start <= THRESHOLD;
            if(isOk) {
                for(int i = start; i <= end; i ++) {
                    sum += i;
                }
    //            System.out.println(String.format("compute %d-%d = %d", start, end, sum));
                return sum;
            }
    
            //除以2
            int middle = (end + start) / 2;
            //子任务递归
    //        System.out.println(String.format("fork %d-%d => %d-%d&%d-%d", start, end, start, middle - 1, middle, end));
            SumTask2 sumSubTask = new SumTask2(start, middle - 1);
            SumTask2 sumSubTask1 = new SumTask2(middle, end);
    
            //fork子任务
            invokeAll(sumSubTask, sumSubTask1);
    
            //join子任务
            Integer join = sumSubTask.join();
            Integer join1 = sumSubTask1.join();
    
            sum = join + join1;
            //计算结果
            return sum;
        }
    }

    测试

         ForkJoinPool fjp2 = new ForkJoinPool();
            SumTask2 sumTask2 = new SumTask2(start, end);
            long begin3 = System.currentTimeMillis();
            Integer invoke = fjp2.invoke(sumTask2);
            long end3 = System.currentTimeMillis();
            System.out.println("计算结果3为 sum = " + invoke + ",计算时长为" + begin3 + "-" + end3 + "---  " + (end3 - begin3) + "ms");
    
            ForkJoinPool fjp = new ForkJoinPool();
            long begin2 = System.currentTimeMillis();
            SumTask sumTask = new SumTask(start, end);
            ForkJoinTask<Integer> submit = fjp.submit(sumTask);
            Integer join = submit.join();
            long end2 = System.currentTimeMillis();
            System.out.println("计算结果2为 sum = " + join + ",计算时长为" + begin2 + "-" + end2 + "---   " + (end2 - begin2) + "ms");
        

    结果

    从结果(可以多次运行测试)可以看出,使用invokeAll方式效率比使用单独fork方式高,所以在使用时尽量采用invokeAll方式,这样可以充分利用线程池中的线程去执行任务。

    源码参照Github

  • 相关阅读:
    spring security如何添加无需鉴权的接口?
    框架——切面框架——aop——weave timing
    框架——切面框架——aop——@Aspect
    框架——切面框架——aop——集成Spring
    ffmpeg q:v 2 表示输出的图片质量,一般是1到5之间(1 为质量最高)
    衡量机器学习模型的三大指标:准确率、精度和召回率。
    Pytorch的permute函数,将tensor的维度换位
    深度学习模型评价指标(准确率、精确率、召回率、F1、ROC、AUC)
    【项目】项目155
    【项目】项目154
  • 原文地址:https://www.cnblogs.com/kingsonfu/p/11172118.html
Copyright © 2020-2023  润新知