fork/join的使用

最新推荐文章于 2024-03-13 09:30:01 发布

520_HL

最新推荐文章于 2024-03-13 09:30:01 发布

阅读量1.2k

点赞数

分类专栏：后台文章标签： java

本文链接：https://blog.csdn.net/qq_42917455/article/details/118366582

版权

后台专栏收录该内容

11 篇文章 0 订阅

订阅专栏

CPU密集型（CPU-bound）
CPU密集型也叫计算密集型，指的是系统的硬盘、内存性能相对CPU要好很多，此时，系统运作大部分的状况是CPU Loading 100%，CPU要读/写I/O(硬盘/内存)，I/O在很短的时间就可以完成，而CPU还有许多运算要处理，CPU Loading很高。在多重程序系统中，大部份时间用来做计算、逻辑判断等CPU动作的程序称之CPU bound。例如一个计算圆周率至小数点一千位以下的程序，在执行的过程当中绝大部份时间用在三角函数和开根号的计算，便是属于CPU bound的程序。 CPU bound的程序一般而言CPU占用率相当高。这可能是因为任务本身不太需要访问I/O设备，也可能是因为程序是多线程实现因此屏蔽掉了等待I/O的时间。
线程数一般设置为：线程数 = CPU核数+1 (现代CPU支持超线程)
IO密集型（I/O bound）
IO密集型指的是系统的CPU性能相对硬盘、内存要好很多，此时，系统运作，大部分的状况是CPU在等I/O (硬盘/内存) 的读/写操作，此时CPU Loading并不高。 I/O bound的程序一般在达到性能极限时，CPU占用率仍然较低。这可能是因为任务本身需要大量I/O操作，而pipeline做得不是很好，没有充分利用处理器能力。
线程数一般设置为：线程数 = （（线程等待时间+线程CPU时间）/线程CPU时间）* CPU数目

什么是 Fork/Join 框架？

Fork/Join 框架是 Java7 提供了的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架,解决CPU密集型问题
Fork/Jion特性：

ForkJoinPool 不是为了替代 ExecutorService，而是它的补充，在某些应用场景下性能比 ExecutorService 更好。
ForkJoinPool 主要用于实现“分而治之”的算法，特别是分治之后递归调用的函数，例如 quick sort 等。
ForkJoinPool 最适合的是计算密集型的任务，如果存在 I/O，线程间同步，sleep() 等会造成线程长时间阻塞的情况时，最好配合使用 ManagedBlocker。

工作窃取算法

工作窃取（work-stealing）算法是指某个线程从其他队列里窃取任务来执行。我们需要做一个比较大的任务，我们可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争，于是把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应，比如A线程负责处理A队列里的任务。但是有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。工作窃取算法的优点是充分利用线程进行并行计算，并减少了线程间的竞争，其缺点是在某些情况下还是存在竞争，比如双端队列里只有一个任务时。并且消耗了更多的系统资源，比如创建多个线程和多个双端队列。
在这里插入图片描述
2. ForkJoinPool 的每个工作线程都维护着一个工作队列（WorkQueue），这是一个双端队列（Deque），里面存放的对象是任务（ForkJoinTask）。
3. 每个工作线程在运行中产生新的任务（通常是因为调用了 fork()）时，会放入工作队列的队尾，并且工作线程在处理自己的工作队列时，使用的是 LIFO 方式，也就是说每次从队尾取出任务来执行。
3. 每个工作线程在处理自己的工作队列同时，会尝试窃取一个任务（或是来自于刚刚提交到 pool 的任务，或是来自于其他工作线程的工作队列），窃取的任务位于其他线程的工作队列的队首，也就是说工作线程在窃取其他工作线程的任务时，使用的是 FIFO 方式。
4. 在遇到 join() 时，如果需要 join 的任务尚未完成，则会先处理其他任务，并等待其完成。 5. 在既没有自己的任务，也没有可以窃取的任务时，进入休眠。

fork/join的使用

ForkJoinTask：我们要使用 ForkJoin 框架，必须首先创建一个 ForkJoin 任务。它提供在任务中执行 fork() 和 join() 操作的机制，通常情况下我们不需要直接继承 ForkJoinTask 类，而只需要继承它的子类，Fork/Join 框架提供了以下两个子类： RecursiveAction：用于没有返回结果的任务。(比如写数据到磁盘，然后就退出了。一个RecursiveAction可以把自己的工作分割成更小的几块，这样它们可以由独立的线程或者CPU执行。我们可以通过继承来实现一个RecursiveAction) RecursiveTask ：用于有返回结果的任务。(可以将自己的工作分割为若干更小任务，并将这些子任务的执行合并到一个集体结果。可以有几个水平的分割和合并) CountedCompleter：在任务完成执行后会触发执行一个自定义的钩子函数

package com.lz.md.test;

import com.lz.md.utils.CalcUtil;
import com.lz.md.utils.Utils;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;

/**
 * @Author longzheng
 * @Date 2021/6/30
 * @Description
 */
public class TestForkJoinTask {
    /**
     * 获取逻辑处理器数量
     */
    static final int NCPU = Runtime.getRuntime().availableProcessors();


    public static void main(String[] args) throws Exception {
        int[] array = Utils.buildRandomIntArray(2000);
        //采用fork/join方式将数组求和任务进行拆分执行，最后合并结果
        LongSumTest ls = new LongSumTest(array, 0, array.length);
        //使用的线程数
        ForkJoinPool fjp = new ForkJoinPool(NCPU);
        ForkJoinTask<Long> task = fjp.submit(ls);
        //用于判断任务计算是否发生异常
        if (task.isCompletedAbnormally()) {
            System.out.println(task.getException());
        }
        fjp.shutdown();
        // 多线程-forkjoin排序
        int[] arrayToSortSingleThread = Utils.buildRandomIntArray(20000000);
        int[] arrayToSortMultiThread = Arrays.copyOf(arrayToSortSingleThread, arrayToSortSingleThread.length);
        MergeSortActionTest mergeSortAction = new MergeSortActionTest(arrayToSortMultiThread, NCPU);
        ForkJoinPool forkJoinPool = new ForkJoinPool(NCPU);
        forkJoinPool.invoke(mergeSortAction);
        //
        List<BigInteger> list = new ArrayList<>();
        for (int i = 3; i < 20; i++) {
            list.add(new BigInteger(Integer.toString(i)));
        }
        ForkJoinPool.commonPool().invoke(
                new FactorialTaskTest(null, list));
    }

}
/**
 * RecursiveTask 并行计算，同步有返回值
 * ForkJoin框架处理的任务基本都能使用递归处理，比如求斐波那契数列等，但递归算法的缺陷是：
 *    一只会只用单线程处理，
 *    二是递归次数过多时会导致堆栈溢出；
 * ForkJoin解决了这两个问题，使用多线程并发处理，充分利用计算资源来提高效率，同时避免堆栈溢出发生。
 * 当然像求斐波那契数列这种小问题直接使用线性算法搞定可能更简单，实际应用中完全没必要使用ForkJoin框架，
 * 所以ForkJoin是核弹，是用来对付大家伙的，比如超大数组排序。
 * 最佳应用场景：多核、多内存、可以分割计算再合并的计算密集型任务
 */
class LongSumTest extends RecursiveTask<Long> {

    static final int SEQUENTIAL_THRESHOLD = 1000;

    int low;
    int high;
    int[] array;

    LongSumTest(int[] arr, int lo, int hi) {
        array = arr;
        low = lo;
        high = hi;
    }

    /**
     * fork()方法：将任务放入队列并安排异步执行，一个任务应该只调用一次fork()函数，除非已经执行完毕并重新初始化。
     * tryUnfork()方法：尝试把任务从队列中拿出单独处理，但不一定成功。
     * join()方法：等待计算完成并返回计算结果。
     * isCompletedAbnormally()方法：用于判断任务计算是否发生异常。
     */
    @Override
    protected Long compute() {

        if (high - low <= SEQUENTIAL_THRESHOLD) {
            long sum = 0;
            for (int i = low; i < high; ++i) {
                sum += array[i];
            }
            return sum;

        } else {
            int mid = low + (high - low) / 2;
            LongSumTest left = new LongSumTest(array, low, mid);
            LongSumTest right = new LongSumTest(array, mid, high);
            left.fork();
            right.fork();
            long rightAns = right.join();
            long leftAns = left.join();
            return leftAns + rightAns;
        }
    }
}
class MergeSortActionTest extends RecursiveAction {

    private final int threshold;
    private int[] arrayToSort;

    public MergeSortActionTest(final int[] arrayToSort, final int threshold) {
        this.arrayToSort = arrayToSort;
        this.threshold = threshold;
    }

    @Override
    protected void compute() {
        if (arrayToSort.length <= threshold) {
            // sequential sort
            Arrays.sort(arrayToSort);
            return;
        }

        // Sort halves in parallel
        int midpoint = arrayToSort.length / 2;
        int[] leftArray = Arrays.copyOfRange(arrayToSort, 0, midpoint);
        int[] rightArray = Arrays.copyOfRange(arrayToSort, midpoint, arrayToSort.length);

        MergeSortActionTest left = new MergeSortActionTest(leftArray, threshold);
        MergeSortActionTest right = new MergeSortActionTest(rightArray, threshold);

        //invokeAll(left, right);
        left.fork();
        right.fork();

        left.join();
        right.join();
        // 排序的数组进行归并
        arrayToSort = MergeSortActionTest.merge(left.getSortedArray(), right.getSortedArray());
    }

    public int[] getSortedArray() {
        return arrayToSort;
    }
    public static int[] merge(final int[] leftArray, final int[] rightArray) {
        int[] mergedArray = new int[leftArray.length + rightArray.length];
        int mergedArrayPos = 0;
        int leftArrayPos = 0;
        int rightArrayPos = 0;
        while (leftArrayPos < leftArray.length && rightArrayPos < rightArray.length) {
            if (leftArray[leftArrayPos] <= rightArray[rightArrayPos]) {
                mergedArray[mergedArrayPos] = leftArray[leftArrayPos];
                leftArrayPos++;
            } else {
                mergedArray[mergedArrayPos] = rightArray[rightArrayPos];
                rightArrayPos++;
            }
            mergedArrayPos++;
        }

        while (leftArrayPos < leftArray.length) {
            mergedArray[mergedArrayPos] = leftArray[leftArrayPos];
            leftArrayPos++;
            mergedArrayPos++;
        }

        while (rightArrayPos < rightArray.length) {
            mergedArray[mergedArrayPos] = rightArray[rightArrayPos];
            rightArrayPos++;
            mergedArrayPos++;
        }

        return mergedArray;
    }

}
class FactorialTaskTest extends CountedCompleter<Void> {

    private static int SEQUENTIAL_THRESHOLD = 5;
    private List<BigInteger> integerList;
    private int numberCalculated;

    FactorialTaskTest (CountedCompleter<Void> parent,
                       List<BigInteger> integerList) {
        super(parent);
        this.integerList = integerList;
    }

    @Override
    public void compute () {
        if (integerList.size() <= SEQUENTIAL_THRESHOLD) {
            showFactorial();
        } else {
            int middle = integerList.size() / 2;
            List<BigInteger> rightList = integerList.subList(middle,
                    integerList.size());
            List<BigInteger> leftList = integerList.subList(0, middle);
            addToPendingCount(2);
            FactorialTaskTest taskRight = new FactorialTaskTest(this, rightList);
            FactorialTaskTest taskLeft = new FactorialTaskTest(this, leftList);
            taskLeft.fork();
            taskRight.fork();
        }
        tryComplete();
    }

    @Override
    public void onCompletion (CountedCompleter<?> caller) {
        if (caller == this) {
            System.out.printf("completed thread : %s numberCalculated=%s%n", Thread
                    .currentThread().getName(), numberCalculated);
        }
    }

    private void showFactorial () {

        for (BigInteger i : integerList) {
            BigInteger factorial = CalcUtil.calculateFactorial(i);
            System.out.printf("%s! = %s, thread = %s%n", i, factorial, Thread
                    .currentThread().getName());
            numberCalculated++;
        }
    }
}

520_HL

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
fork/join的使用

CPU密集型（CPU-bound）CPU密集型也叫计算密集型，指的是系统的硬盘、内存性能相对CPU要好很多，此时，系统运作大部分的状况是CPU Loading 100%，CPU要读/写I/O(硬盘/内存)，I/O在很短的时间就可以完成，而CPU还有许多运算要处理，CPU Loading很高。在多重程序系统中，大部份时间用来做计算、逻辑判断等CPU动作的程序称之CPU bound。例如一个计算圆周率至小数点一千位以下的程序，在执行的过程当中绝大部份时间用在三角函数和开根号的计算，便是属于CPU boun
复制链接

扫一扫