Forkjoin架构 归并算法

最新推荐文章于 2022-11-24 15:13:53 发布
最新推荐文章于 2022-11-24 15:13:53 发布
阅读量144 收藏
点赞数
分类专栏： # 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanjiaqian/article/details/120331646
版权

ForkJoin

ForkJoin是由JDK1.7后提供多线并发处理框架，ForkJoin的框架的基本思想是分而治之。使用ForkJoin将相同的计算任务通过多线程的进行执行。从而能提高数据的计算速度。

分而治之

分而治之就是将一个复杂的计算，按照设定的阈值进行分解成多个计算，然后将各个计算结果进行汇总。相应的ForkJoin将复杂的计算当做一个任务。而分解的多个计算则是当做一个子任务。

使用

使用ForkJoin框架，需要创建一个ForkJoin的任务。因为ForkJoin框架为我们提供了RecursiveAction和RecursiveTask。

我们只需要继承ForkJoin为我们提供的抽象类的其中一个并且实现compute方法。

RecursiveTask在进行exec之后会使用一个result的变量进行接受返回的结果。而RecursiveAction在exec后是不会保存返回结果。

任务分割

ForkJoinTask : 基本任务，使用forkjoin框架必须创建的对象，提供fork,join操作，常用的两个子类

  • RecursiveAction : 无结果返回的任务
  • RecursiveTask : 有返回结果的任务

说明：

  1. fork : 让task异步执行
  2. join : 让task同步执行，可以获取返回值
  3. ForkJoinTask 在不显示使用ForkJoinPool.execute/invoke/submit()方法进行执行的情况下，也可以使用自己的fork/invoke方法进行执行

结果合并

ForkJoinPool 执行 ForkJoinTask，

  • 任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。
  • 当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务

三中提交方式：

  1. execute 异步，无返回结果
  2. submit 异步，有返回结果 （返回Future<T>）
  3. invoke 同步，有返回结果 （会阻塞）
package com.bxwell.hj360.device.module.devicedatamanagement.service.impl;

import com.bxwell.hj360.common.base.common.until.StringUtil;
import com.bxwell.hj360.common.model.device.BxWellDeviceFactor;
import com.bxwell.hj360.module.devicedatamanagement.vo.DayDataShowStrVO;
import com.bxwell.hj360.module.devicedatamanagement.vo.HourDataShowStrVO;
import com.bxwell.hj360.module.devicedatamanagement.vo.MinDataShowStrVO;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.ObjectUtils;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class TimeForkJoinPoolCalcRate {


    class CalcTask extends RecursiveAction{


        private final Integer MAX = 100;

        private String deviceId;

        String factorId;

        private Map<String, BigDecimal> unitRateMap;

        private Map<String, BxWellDeviceFactor> cunit;

        private List<MinDataShowStrVO> listMinDataShowVO;

        private List<HourDataShowStrVO> listHourDataShowVO;

        private List<DayDataShowStrVO> listDayDataShowVO;

        private BigDecimal rateBig;

        private BigDecimal totalUnitIdRateBig;

        public CalcTask(String deviceId,String factorId ,Map<String, BigDecimal> unitRateMap,Map<String, BxWellDeviceFactor> cunit,
                        List<MinDataShowStrVO> listMinDataShowVO, List<HourDataShowStrVO> listHourDataShowVO, List<DayDataShowStrVO> listDayDataShowVO,BigDecimal rateBig,BigDecimal totalUnitIdRateBig){
            this.deviceId = deviceId;

            this.factorId = factorId;

            this.unitRateMap = unitRateMap;

            this.cunit = cunit;

            this.listMinDataShowVO = listMinDataShowVO;

            this.listHourDataShowVO = listHourDataShowVO;

            this.listDayDataShowVO = listDayDataShowVO;

            this.rateBig = rateBig;

            this.totalUnitIdRateBig = totalUnitIdRateBig;
        }


        @Override
        protected void compute() {

            if(listMinDataShowVO != null){
                if(listMinDataShowVO.size() <= MAX){
                    handleMinData(listMinDataShowVO);
                }else {
                    handleThreadNum(listMinDataShowVO);
                }
            }else if(listHourDataShowVO != null){
                if(listHourDataShowVO.size() <= MAX){
                    handleHourData(listHourDataShowVO);
                }else {
                    handleThreadNum(listHourDataShowVO);
                }
            }else if(listDayDataShowVO != null){
                if(listDayDataShowVO.size() <= MAX){
                    handleDayData(listDayDataShowVO);
                }else {
                    handleThreadNum(listDayDataShowVO);
                }
            }
        }

        private void handleThreadNum(List<?> list){
            createCalcTask(list,list.size() <= 1000 ? 5 : list.size() <= 10000 ? 10 : list.size() <= 50000 ? 25 : list.size() <= 100000 ? 50 : 100);
        }

        private void handleMinData(List<MinDataShowStrVO> list){
            SimpleDateFormat format =  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for(MinDataShowStrVO vo : list){
                if(!StringUtil.isEmpty(vo.getEndTime())){
                    vo.setTimeStr(format.format(vo.getTime())+"-"+vo.getEndTime());
                }
                if(null != rateBig){
                    if(null != vo.getMin()){
                        vo.setMin(handleRateNum(vo.getMin(),rateBig,true));
                    }
                    if(null != vo.getMax()){
                        vo.setMax(handleRateNum(vo.getMax(),rateBig,true));
                    }
                    if(null != vo.getAvg()){
                        vo.setAvg(handleRateNum(vo.getAvg(),rateBig,true));
                    }
                }else{//如果转换率的两个单位一致 导致取不到转换率 也需要保留有效小数点
                    if(null != vo.getMin()){
                        vo.setMin(handleRateNum(vo.getMin(),null,false));
                    }
                    if(null != vo.getMax()){
                        vo.setMax(handleRateNum(vo.getMax(),null,false));
                    }
                    if(null != vo.getAvg()){
                        vo.setAvg(handleRateNum(vo.getAvg(),null,false));
                    }
                }
                if(null != totalUnitIdRateBig && null != vo.getCou()){
                    vo.setCou(handleRateNum(vo.getCou(),totalUnitIdRateBig,true));
                }
                if(null == totalUnitIdRateBig && null != vo.getCou()){
                    //前端需处理成斜杠
                    vo.setCou(handleRateNum(vo.getCou(),null,false));
                }
            }
        }

        private void handleHourData(List<HourDataShowStrVO> list){

            for(HourDataShowStrVO vo : list){
                if(null != rateBig){
                    if(null != vo.getMin()){
                        vo.setMin(handleRateNum(vo.getMin(),rateBig,true));
                    }
                    if(null != vo.getMax()){
                        vo.setMax(handleRateNum(vo.getMax(),rateBig,true));
                    }
                    if(null != vo.getAvg()){
                        vo.setAvg(handleRateNum(vo.getAvg(),rateBig,true));
                    }
                }else{//如果转换率的两个单位一致 导致取不到转换率 也需要保留有效小数点
                    if(null != vo.getMin()){
                        vo.setMin(handleRateNum(vo.getMin(),null,false));
                    }
                    if(null != vo.getMax()){
                        vo.setMax(handleRateNum(vo.getMax(),null,false));
                    }
                    if(null != vo.getAvg()){
                        vo.setAvg(handleRateNum(vo.getAvg(),null,false));
                    }
                }
                if(null != totalUnitIdRateBig && null != vo.getCou()){
                    vo.setCou(handleRateNum(vo.getCou(),totalUnitIdRateBig,true));
                }
                if(null == totalUnitIdRateBig && null != vo.getCou()){
                    //前端需处理成斜杠
                    vo.setCou(handleRateNum(vo.getCou(),null,false));
                }
            }
        }

        private void handleDayData(List<DayDataShowStrVO> list){
            for(DayDataShowStrVO vo : list){
                if(null != rateBig){
                    if(null != vo.getMin()){
                        vo.setMin(handleRateNum(vo.getMin(),rateBig,true));
                    }
                    if(null != vo.getMax()){
                        vo.setMax(handleRateNum(vo.getMax(),rateBig,true));
                    }
                    if(null != vo.getAvg()){
                        vo.setAvg(handleRateNum(vo.getAvg(),rateBig,true));
                    }
                }else{//如果转换率的两个单位一致 导致取不到转换率 也需要保留有效小数点
                    if(null != vo.getMin()){
                        vo.setMin(handleRateNum(vo.getMin(),null,false));
                    }
                    if(null != vo.getMax()){
                        vo.setMax(handleRateNum(vo.getMax(),null,false));
                    }
                    if(null != vo.getAvg()){
                        vo.setAvg(handleRateNum(vo.getAvg(),null,false));
                    }
                }
                if(null != totalUnitIdRateBig && null != vo.getCou()){
                    vo.setCou(handleRateNum(vo.getCou(),totalUnitIdRateBig,true));
                }
                if(null == totalUnitIdRateBig && null != vo.getCou()){
                    //前端需处理成斜杠
                    vo.setCou(handleRateNum(vo.getCou(),null,false));
                }
            }
        }

        private void createCalcTask(List<?> list,int num){
            int cou = 0;
            if(list != null){
                List<? extends List<?>> lists = rangeList(list, list.size() / num);
                while (cou < lists.size()){
                    CalcTask calcTask = new CalcTask(deviceId,factorId, unitRateMap, cunit,
                            listMinDataShowVO != null ? (List<MinDataShowStrVO>)lists.get(cou) : null,
                            listHourDataShowVO != null ? (List<HourDataShowStrVO>)lists.get(cou) : null,
                            listDayDataShowVO != null ? (List<DayDataShowStrVO>)lists.get(cou) : null,
                            rateBig,totalUnitIdRateBig);
                    cou++;
                    calcTask.fork();
                    calcTask.join();
                }
            }
        }

        /**
         * 平均分割集合 最后一个角标数据取余
         * @param list 数据集合
         * @param size  []
         * @param <T>
         * @return
         */
        private <T> List<List<T>> rangeList(List<T>list , int size){
            if(ObjectUtils.isEmpty(list)){
                return Collections.emptyList();
            }
            int block = (list.size() + size -1) / size;
            return IntStream.range(0,block).
                    boxed().map(i->{
                int start = i*size;
                int end = Math.min(start + size,list.size());
                return list.subList(start,end);
            }).collect(Collectors.toList());
        }

    }

    /**
     *  返回保留几位小数
     * @param str
     * @return
     */
    private static int countNum(String str){
        int d = str.indexOf(".");
        String str2 = str.substring(d+1,str.length());
        String[] split = str2.split("");
        int num = 2;
        for (int a = 0;a < split.length;a++) {
            if(!split[a].equals("0")){
                if(a > 1){
                    num = a+2;
                    break;
                }
            }
        }
        return num;
    }

    /**
     * 根据规则保留有效数字
     * @param val 转换值
     * @param val2 转换率
     * @boolean calc 是否计算
     * @return
     */
    public static String handleRateNum(String val,BigDecimal val2,boolean calc){
        if(val == null){
            return null;
        }
        BigDecimal vall = new BigDecimal(val);
        if(StringUtils.isNotBlank(val) && val2 != null && calc){
            vall = vall.multiply(val2);
        }
        BigDecimal bigdecimal = null;
        //小于0.01跟-0.01需要保留有效位数两位
        if(vall.compareTo(new BigDecimal(0.01)) == -1){
            bigdecimal = vall.setScale(countNum(vall.toPlainString()),BigDecimal.ROUND_HALF_UP);
        }else{
            //大于0.01需要保留两位小数
            bigdecimal = vall.setScale(2,BigDecimal.ROUND_HALF_UP);
        }
        //如果保留的两位小数是00的话直接取整
        if(bigdecimal.intValue() > 0 && String.valueOf(bigdecimal).contains("00")){
            return String.valueOf(bigdecimal.setScale(0,BigDecimal.ROUND_UP));
        }else{
            return bigdecimal.stripTrailingZeros().toPlainString();
        }
    }

    public static void main(String[] args) {
        System.out.println(handleRateNum("2777.77777778",new BigDecimal(3.600000000000),true));
    }

    /**
     *
     * @param deviceId
     * @param factorId
     * @param unitRateMap 单位转换map
     * @param cunit 自定义单位 基准单位map 累计值单位
     * @param listMinDataShowVO
     * @param listHourDataShowVO
     * @param listDayDataShowVO
     * @throws InterruptedException
     */
    public static void CalcRate(String deviceId,String factorId, Map<String, BigDecimal> unitRateMap, Map<String, BxWellDeviceFactor> cunit,
                                List<MinDataShowStrVO> listMinDataShowVO, List<HourDataShowStrVO> listHourDataShowVO, List<DayDataShowStrVO> listDayDataShowVO) throws InterruptedException {
        if(cunit.get(deviceId +"_"+ factorId) == null){
            return;
        }
        //自定义单位
        BigDecimal rateBig = unitRateMap.get(cunit.get(deviceId +"_"+ factorId).getCUnit());
        //自定义累计单位
        String totalUnitId = cunit.get(deviceId + "_" + factorId).getTotalUnitId();
        String factorTotalUnitId = cunit.get(deviceId + "_" + factorId).getFactorTotalUnitId();
        BigDecimal totalUnitIdRateBig = unitRateMap.get(totalUnitId + "_" + factorTotalUnitId);
        ForkJoinPool pool = new ForkJoinPool();
        pool.invoke(new TimeForkJoinPoolCalcRate().new CalcTask(deviceId,factorId, unitRateMap, cunit,
                listMinDataShowVO,listHourDataShowVO,listDayDataShowVO,
                rateBig,totalUnitIdRateBig));
        pool.shutdown();
    }

}

hanjq_code
关注
专栏目录
JUC并行计算框架 Fork/Join 原理图文详解&代码示例
AI天才研究院
05-03 9164
关键词：divide and conquer algorithm，work-stealing，WorkQueue ForkJoinPool 是什么？ ForkJoinPool 是 JDK 7 中，@author Doug Lea 加入的一个线程池类。Fork/Join 框架的核心原理就是分治算法（Divide-and-Conquer）和工作窃取算法（work-stealing algorithm）...
Fork/Join 归并算法
PJF1501105594的博客
02-27 397
Fork/Join框架是Java 7提供的一个用于并行执行任务的框架，一个把大任务分割成多个小任务，最终汇总每个小任务结果后得到大任务结果的框架。Fork/Join框架要完成两件事情： 　　1.任务分割：首先Fork/Join框架需要把大的任务分割成小的子任务，若子任务比较大的话还要对子任务进行继续分割 　　2.执行任务并合并结果：分割的子任务分别放到双端队列里，然后几个启动线程分别从双端队列...
JAVA——归并算法 Fork/Join框架
qq_39405179的博客
05-30 196
来源：http://blog.csdn.net/yinwenjie简单的归并算法实现import java.util.Arrays; import java.util.Random; import java.util.concurrent.ForkJoinPool; public class MergeSort { private static int MAX=10000; priva...
ForkJoin算法实现
Coding Road
06-15 452
要求 一个数组内有10万个30左右的数值（非零），要求计算这些值的乘积。 - 时间要求：2s - 堆内存大小：4m 实现方案 通过ForkJoin实现。 代码实现 import com.google.common.base.Joiner; import com.google.common.base.Splitter; import org.apache.commons.l...
使用Fork/Join框架优化归并排序
ChesterChai的博客
08-03 390
Fork/Join框架是一个非常有意思的并发框架，它非常适合于处理类似归并排序这种将大的问题分解成多个小问题，并将结果进行合并的情况，这次我们就使用Fork/Join框架来优化我们的归并排序。查看更多有关Fork/Join框架的知识，请点击这里; 首先为了与普通单线程归并排序对比，我们先来写一个传统的归并排序： import java.util.Arrays; public class Test...
Fork/Join(2)：归并排序
刘涛的编程笔记
12-25 1174
fork/join框架是分治法的体现，因此特别适合归并排序这种分治算法。 　　单线程测试排序2亿个整数约59349毫秒，使用fork/join测试排序约34635毫秒。可以看到，fork/join框架充分运用了CPU的计算能力，执行时间缩短了近一半。
Java Fork_Join框架源码深度剖析：设计理念与架构揭秘
[Java Fork_Join框架源码深度剖析：设计理念与架构揭秘](http://thetechstack.net/assets/images/posts/forkjointask-classes.png) # 1. Java Fork/Join框架概述 Java Fork/Join框架是JDK 7中引入的一个用于并行...
Fork_Join框架在大数据处理中的应用：5个案例研究与剖析
[Fork_Join框架在大数据处理中的应用：5个案例研究与剖析](https://media.geeksforgeeks.org/wp-content/uploads/20210404122934/forkjoin.png) # 1. Fork_Join框架概述与理论基础 ## 1.1 Fork_Join框架的定义与...
Fork_Join框架优化宝典：3个案例分析与7大最佳实践
## 1.1 什么是Fork_Join框架 Fork_Join框架是Java 7中引入的一种用于并行执行任务的框架。它利用了多核处理器的优势，通过递归地将大任务划分成多个小任务，并行地执行这些任务，最后将子任务的结果合并以完成整个...
Java并发编程进阶：Fork_Join框架的高级用法与案例分析
![Java并发编程进阶：Fork_Join框架的高级用法与案例分析](http://thetechstack.net/assets/images/posts/forkjointask-classes.png) ...Java提供了多种并发编程模型，包括线程与锁、Executor框架、Fork/Join框架等。
C++数据结构和算法2 栈 双端/队列 冒泡选择插入归并快排 二三分查找 二叉树 二叉搜索树 贪婪 分治 动态规划
万有文的博客
01-24 876
C++数据结构和算法2 栈 双端/队列 冒泡选择插入归并快排 二三分查找 二叉树 二叉搜索树 贪婪 分治 动态规划 github 章3 Stack栈 和 队列Queue=========================== 3.1 Stack栈 叠起来的 碗，放在一摞的书…都是栈的实例… 一种 插入 和 删除 操作只能在一端( 栈顶Top() )进行的 容器 是一种 后进先出(Last In F...
Fork/Join框架基本使用
热门推荐
tyrroo的博客
08-06 7万+
1. 概述 ava.util.concurrent.ForkJoinPool由Java大师Doug Lea主持编写，它可以将一个大的任务拆分成多个子任务进行并行处理，最后将子任务结果合并成最后的计算结果，并进行输出。本文中对Fork/Join框架的讲解，基于JDK1.8+中的Fork/Join框架实现，参考的Fork/Join框架主要源代码也基于JDK1.8+。 这几篇文章将试图解释Fork/...
fork-join详解（2）
qfzhaohan的博客
11-12 1379
4.fork-join实战异步读取磁盘文件 本次采用execute异步来启动ForkJoinPool,小伙伴们可以看启动结果跟invoke启动的区别 具体思路: 1.首先拿到我当前这个磁盘下的所有文件遍历循环 2.循环中判断文件是否是目录,如果是目录再次使用递归任务进行任务添加 3.如果不是目录就输出文件路径 4.对添加到目录递归任务集合中的数据再次进行递归 具体代码： public class main { //读取文件任务对象 static class FileTa
Fork/Join工作原理解析
sermonlizhi的博客
03-05 1978
一、如何高效利用CPU 在介绍Fork/Join框架之前，思考一个问题，在多线程的情况下，如何才能高效的利用CPU，以常用的线程池为例，线程池的线程数设置多少合适？ 通常调整线程池中的线程数量其核心目的就是为了能够充分的利用CPU和内存资源，从而最大限度的提高程序的性能。在实际工作中，我们可能会根据任务类型的不同而采取不同的策略。按照一个任务执行过程中使用CPU的时间和任务总耗时的比例，可以将任务分为两种：CPU密集型任务和IO密集型任务 1.1 任务类型 1.1.1 CPU密集型任务 CPU密集型任务也称
系统结构-并行算法FORK JOIN
Hogwarts
06-15 6091
并行算法FORK JOIN一、FORK JOIN定义二、举例题目分析： 一、FORK JOIN定义 FORK语句的形式： FORK m,其中m为新进程开始的标号。 执行FORK m语句时,派生出标号为m开始的新进程,具体为: 1、准备好这个新进程启动和执行所必需的信息; 2、如果是共享主存,则产生存储器指针、映像函数和访问权数据; 3、将空闲的处理机分配给派生的新进程,如果没有空闲处理机,则让它们排队等待; 4、继续在原处理机上执行FORK语句的原进程。 与FORK语句相配合,作为每个并发进程的终端语句J
fork/join使用介绍
weixin_40533111的博客
12-06 1349
前言 fork/join是jdk1.7提出的分治编程的一个框架,适合处理单进程的大任务 目录 1.介绍 2.工作窃取算法 3.使用 正文 介绍 简单流程是:把一个大任务拆分(fork)为几个小任务,可根据阈值判断是否继续拆分为小小任务,然后收集(join)每个任务执行的结果.如图所示: 工作窃取算法 fork/join优秀的地方就在于这个算法,假如我们需要做一个比较大的任务，我们可以把这个任务分...
【前端验证】fork-join_none线程立即执行的一次代码优化记录
最新发布
moon9999的博客
11-24 1114
【system verilog】fork-join_none与循环语句共同使用的行为探究很早之前写过关于fork-join_none的探究文章，最近被人指出了一些错误：我仔细理解了下他的意思，觉得确实使用#0来立刻进行进行阻塞，进而达到立即执行fork-join_none内语句的方式是比较合理的（当然了，其他阻塞行为一样会让fork-join_none内的语句执行，但不能达到立刻执行的效果）。经过这个勘误和指点后，我突然觉得又通彻了一些。
使用ForkJoin框架实现归并排序
jay1on的博客
06-07 974
Fork/Join Fork/Join是一种采用“分治法”思想的框架，即将一个大问题拆分为无数个相同的小问题，然后各个击破再统一组装。jdk中的ForkJoinPool就是使用fork/join框架的多线程工具类（同其他线程池一样，扩展自抽象类AbstractExecutorService），我们只需要编写如何拆分任务的代码，它就能自动使用多线程去处理子任务，为我们屏蔽了线程的创建和使用细节，并且支持work−stealing(工作密取)。 工作密取（work−stealing） 在forkjoin中
运用ForkJoin多线程框架实现归并排序
rootlh的博客
09-05 2361
一、普通归并排序 1public class MergeSort {23    /**4     * 原地归并排序（每次只将数组分为大和小两部分，并不是完全排序完成。需要递归）5     *6     * @param arr7     * @param lo8     * @param mid9     * @param hi10     */11    public void m
归并排序算法详解与实现
"归并算法是一种排序方法，它利用了分治策略，通过将小规模的有序序列合并成大规模的有序序列来实现整个序列的排序。归并排序的核心在于两路归并操作，即将两个已经排序的子序列合并成一个有序序列。在实际应用中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值