内容字号:默认大号超大号

段落设置:段首缩进取消段首缩进

字体设置:切换到微软雅黑切换到宋体

使用分支/合并框架执行并行求和

2019-01-07 20:22 出处:清屏网 人气: 评论(0

分支/合并框架

​ 分支/合并框架的目的是以递归方式将可以并行的任务拆分成更小的任务,然后将每个子任

务的结果合并起来生成整体结果。它是ExecutorService接口的一个实现,它把子任务分配给

线程池(称为ForkJoinPool)中的工作线程。首先来看看如何定义任务和子任务。

使用RecursiveTask

​ 要把任务提交到这个池,必须创建RecursiveTask 的一个子类,其中R是并行化任务(以 及所有子任务)产生的结果类型,或者如果任务不返回结果,则是RecursiveAction类型(当 然它可能会更新其他非局部机构)。要定义RecursiveTask,只需实现它唯一的抽象方法 compute:

protected abstract R compute();

​ 这个方法同时定义了将任务拆分成子任务的逻辑,以及无法再拆分或不方便再拆分时,生成 单个子任务结果的逻辑。

​ 正由于此,这个方法的实现类似于下面的伪代码:

if (任务足够小或不可分) { 顺序计算该任务
} else {
     将任务分成两个子任务
     递归调用本方法,拆分每个子任务,等待所有子任务完成
     合并每个子任务的结果
}

​ 一般来说并没有确切的标准决定一个任务是否应该再拆分,但有几种试探方法可以帮助你做

出这一决定,递归的任务拆分过程如图下图所示:

​ 你可能已经注意到,这只不过是著名的分治算法的并行版本而已。这里举一个用分支/合并

框架的实际例子,让我们试着用这个框架为一个数字范围(这里用一个

long[]数组表示)求和。如前所述,你需要先为RecursiveTask类做一个实现,就是下面代码

ForkJoinSumCalculator。

用分支/合并框架执行并行求和

package java8.java8example;

import java.util.concurrent.RecursiveTask;

/**
 * @desctiption:
 * @author: yinghuaYang
 * @date: 2019/1/7
 */

public class ForkJoinSumCalculator extends RecursiveTask<Long> {
    /**
     * 要求和的数组
     */
    private final long[] numners;

    /**
     * 子任务处理的数组的起始位置
     */
    private final int start;

    /**
     * 子任务处理的数组的终止位置
     */
    private final int end;

    /**
     * 不再将任务分解为子任务的数组大小
     */
    public static final long THRESHOLD = 10000;

    /**
     * 公共构造方法用于创建主任务
     * @param numners
     */
    public ForkJoinSumCalculator(long[] numners) {
        this(numners,0,numners.length);
    }

    /**
     * 私有构造方法用于以递归方式为主任务创建子任务
     * @param numners
     * @param start
     * @param end
     */
    private ForkJoinSumCalculator(long[] numners, int start, int end) {
        this.numners = numners;
        this.start = start;
        this.end = end;
    }

    /**
     * 覆盖RecursiveTask抽象方法
     *
     * 该任务负责求和的步伐的大小
     * @return
     */
    @Override
    protected Long compute() {
        int length = end - start;

         /*如果大小小于或等于阈值,顺序执行计算结果*/
        if (length <= THRESHOLD) {
            return computeSequentially();
        }

        ForkJoinSumCalculator leftTask = new ForkJoinSumCalculator(numners,start,start+length/2);
        leftTask.fork();

        /*创建一个任务为数组的后一半求和*/
        ForkJoinSumCalculator rightTask = new ForkJoinSumCalculator(numners,start+length/2,end);

        /*同步执行第二个子任务,有可能允许进一步递归划分*/
        Long rightResult = rightTask.compute();

        /*读取第一个子任务的结果,如果尚未完成就等待*/
        Long leftResult = leftTask.join();

        /*该任务的结果是两个子任务结果的组合*/
        return leftResult + rightResult;
    }

    /**
     * 在子任务不再可分时及时结果的简单写法
     * @return
     */
    private long computeSequentially() {
        long sum = 0;

        for (int i=0;i<end;i++) {
            sum += numners[i];
        }

        return sum;
    }

}

​ 现在编写一个方法来并行对前n个自然数求和就很简单了。你只需把想要的数字数组传给

ForkJoinSumCalculator的构造函数:

package java8.java8example;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

/**
 * @desctiption:
 * @author: yinghuaYang
 * @date: 2019/1/7
 */

public class ForkJoinSumCalculatorMain {

    public static long forkJoinSum(long n) {
        long[] numbers = LongStream.rangeClosed(1,n).toArray();

        ForkJoinTask<Long> task = new ForkJoinSumCalculator(numbers);

        return new ForkJoinPool().invoke(task);
    }

    public static void main(String[] args) {
        long totalResult = forkJoinSum(10000L);
        System.out.println(totalResult);
    }
}

注意:

​ 上面用了一个LongStream来生成包含前n个自然数的数组,然后创建一个ForkJoinTask (RecursiveTask的父类),并把数组传递给代码所示ForkJoinSumCalculator的公共 构造函数。最后,你创建了一个新的ForkJoinPool,并把任务传给它的调用方法 。

​ 在 ForkJoinPool中执行时,最后一个方法返回的值就是ForkJoinSumCalculator类定义的任务结果。 请注意在实际应用时,使用多个ForkJoinPool是没有什么意义的。正是出于这个原因,一般来说把它实例化一次,然后把实例保存在静态字段中,使之成为单例,这样就可以在软件中任 何部分方便地重用了。这里创建时用了其默认的无参数构造函数,这意味着想让线程池使用JVM 能够使用的所有处理器。更确切地说,该构造函数将使用Runtime.availableProcessors的 返回值来决定线程池使用的线程数。请注意availableProcessors方法虽然看起来是处理器, 但它实际上返回的是可用内核的数量,包括超线程生成的虚拟内核。

​ 运行ForkJoinSumCalculator,当把ForkJoinSumCalculator任务传给ForkJoinPool时,这个任务就由池中的一个线程 执行,这个线程会调用任务的compute方法。该方法会检查任务是否小到足以顺序执行,如果不 够小则会把要求和的数组分成两半,分给两个新的ForkJoinSumCalculator,而它们也由 ForkJoinPool安排执行。

​ 因此,这一过程可以递归重复,把原任务分为更小的任务,直到满足 不方便或不可能再进一步拆分的条件(本例中是求和的项目数小于等于10 000)。这时会顺序计 算每个任务的结果,然后由分支过程创建的(隐含的)任务二叉树遍历回到它的根。接下来会合 并每个子任务的部分结果,从而得到总任务的结果。

这一过程如图下图所示:

分享给小伙伴们:
本文标签: Java

相关文章

发表评论愿您的每句评论,都能给大家的生活添色彩,带来共鸣,带来思索,带来快乐。

CopyRight © 2015-2016 QingPingShan.com , All Rights Reserved.

清屏网 版权所有 豫ICP备15026204号