Forkjoin架构 归并算法

最新推荐文章于 2022-11-24 15:13:53 发布
最新推荐文章于 2022-11-24 15:13:53 发布
阅读量129 收藏
点赞数
分类专栏： # 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Fork/Join 归并算法
PJF1501105594的博客
02-27 370
Fork/Join框架是Java 7提供的一个用于并行执行任务的框架，一个把大任务分割成多个小任务，最终汇总每个小任务结果后得到大任务结果的框架。Fork/Join框架要完成两件事情： 　　1.任务分割：首先Fork/Join框架需要把大的任务分割成小的子任务，若子任务比较大的话还要对子任务进行继续分割 　　2.执行任务并合并结果：分割的子任务分别放到双端队列里，然后几个启动线程分别从双端队列...
JAVA——归并算法 Fork/Join框架
qq_39405179的博客
05-30 179
来源：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 429
要求 一个数组内有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 371
Fork/Join框架是一个非常有意思的并发框架，它非常适合于处理类似归并排序这种将大的问题分解成多个小问题，并将结果进行合并的情况，这次我们就使用Fork/Join框架来优化我们的归并排序。查看更多有关Fork/Join框架的知识，请点击这里; 首先为了与普通单线程归并排序对比，我们先来写一个传统的归并排序： import java.util.Arrays; public class Test...
Fork/Join(2)：归并排序
刘涛的编程笔记
12-25 1160
fork/join框架是分治法的体现，因此特别适合归并排序这种分治算法。 　　单线程测试排序2亿个整数约59349毫秒，使用fork/join测试排序约34635毫秒。可以看到，fork/join框架充分运用了CPU的计算能力，执行时间缩短了近一半。
C++归并算法实例
12-26
本文实例讲述了C++归并算法。分享给大家供大家参考。具体如下： /* 归并算法：把两个或两个以上的线性表合并在一起，形成一个新的线性表 函数模版的基本使用 程序意图：将两个相同类型的线性表元素排好序，然后...
归并算法归并算法
04-17
### 归并算法详解 #### 一、归并算法概览 归并算法，更确切地说，归并排序，是一种高效的排序算法，基于分治策略。它的核心思想是将数组分成若干部分，对每一部分单独排序，再将排序好的部分合并成一个整体，最终...
三分钟带你看懂归并排序算法
最新发布
07-27
归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。 算法思路 归并排序算法有两...
C++多路归并算法汇总
03-05
C++多路归并算法汇总，包括题目和解题思路等
C++数据结构和算法2 栈 双端/队列 冒泡选择插入归并快排 二三分查找 二叉树 二叉搜索树 贪婪 分治 动态规划
万有文的博客
01-24 847
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 1275
4.fork-join实战异步读取磁盘文件 本次采用execute异步来启动ForkJoinPool,小伙伴们可以看启动结果跟invoke启动的区别 具体思路: 1.首先拿到我当前这个磁盘下的所有文件遍历循环 2.循环中判断文件是否是目录,如果是目录再次使用递归任务进行任务添加 3.如果不是目录就输出文件路径 4.对添加到目录递归任务集合中的数据再次进行递归 具体代码： public class main { //读取文件任务对象 static class FileTa
Fork/Join工作原理解析
sermonlizhi的博客
03-05 1783
一、如何高效利用CPU 在介绍Fork/Join框架之前，思考一个问题，在多线程的情况下，如何才能高效的利用CPU，以常用的线程池为例，线程池的线程数设置多少合适？ 通常调整线程池中的线程数量其核心目的就是为了能够充分的利用CPU和内存资源，从而最大限度的提高程序的性能。在实际工作中，我们可能会根据任务类型的不同而采取不同的策略。按照一个任务执行过程中使用CPU的时间和任务总耗时的比例，可以将任务分为两种：CPU密集型任务和IO密集型任务 1.1 任务类型 1.1.1 CPU密集型任务 CPU密集型任务也称
系统结构-并行算法FORK JOIN
Hogwarts
06-15 5905
并行算法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 1318
前言 fork/join是jdk1.7提出的分治编程的一个框架,适合处理单进程的大任务 目录 1.介绍 2.工作窃取算法 3.使用 正文 介绍 简单流程是:把一个大任务拆分(fork)为几个小任务,可根据阈值判断是否继续拆分为小小任务,然后收集(join)每个任务执行的结果.如图所示: 工作窃取算法 fork/join优秀的地方就在于这个算法,假如我们需要做一个比较大的任务，我们可以把这个任务分...
【前端验证】fork-join_none线程立即执行的一次代码优化记录
moon9999的博客
11-24 1002
【system verilog】fork-join_none与循环语句共同使用的行为探究很早之前写过关于fork-join_none的探究文章，最近被人指出了一些错误：我仔细理解了下他的意思，觉得确实使用#0来立刻进行进行阻塞，进而达到立即执行fork-join_none内语句的方式是比较合理的（当然了，其他阻塞行为一样会让fork-join_none内的语句执行，但不能达到立刻执行的效果）。经过这个勘误和指点后，我突然觉得又通彻了一些。
使用ForkJoin框架实现归并排序
jay1on的博客
06-07 901
Fork/Join Fork/Join是一种采用“分治法”思想的框架，即将一个大问题拆分为无数个相同的小问题，然后各个击破再统一组装。jdk中的ForkJoinPool就是使用fork/join框架的多线程工具类（同其他线程池一样，扩展自抽象类AbstractExecutorService），我们只需要编写如何拆分任务的代码，它就能自动使用多线程去处理子任务，为我们屏蔽了线程的创建和使用细节，并且支持work−stealing(工作密取)。 工作密取（work−stealing） 在forkjoin中
运用ForkJoin多线程框架实现归并排序
rootlh的博客
09-05 2216
一、普通归并排序 1public class MergeSort {23    /**4     * 原地归并排序（每次只将数组分为大和小两部分，并不是完全排序完成。需要递归）5     *6     * @param arr7     * @param lo8     * @param mid9     * @param hi10     */11    public void m
ForkJoin实现归并排序
破草的博客
05-30 691
public class MergeSortAction extends RecursiveAction { private final int threshold; private int[] arrayToSort; public MergeSortAction(final int[] arrayToSort, final int threshold) { this.array...
归并排序中的归并算法
09-05
归并排序是一种经典的排序算法，它基于分治的思想。归并排序的核心操作是归并（Merge）算法，用于将两个已经排序的序列合并成一个有序的序列。 归并算法的步骤如下： 1. 创建一个临时数组，用于存储合并后的结果。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值