Fork/Join：JDK并发包-线程池-分而治之

最新推荐文章于 2024-03-01 14:03:03 发布

湯神码

最新推荐文章于 2024-03-01 14:03:03 发布

阅读量153

点赞数

分类专栏：学习文章标签： java 并发编程

原文链接：https://www.cnblogs.com/daishengda/p/8909524.html

版权

学习专栏收录该内容

41 篇文章 2 订阅

订阅专栏

1、Fork/Join简介

1.1、分而治之

一个非常有效地处理大量数据的方法。著名的MapReduce也是采取分而治之的思想。简单来说，就是如果你要处理1000个数据，但是你并不具备处理1000个数据的能力，那么你可以只处理其中的10个，然后分阶段处理100次，将100次的结果进行合并，那就是最终想要的对原始1000个数据的处理结果。

1.2、Fork/Join框架

Java中通过使用fork()后系统多了一个执行分支(线程)，索引需要等待这个执行分支执行完毕，才有可能得到最终结果，因此join就表示等待。

如果毫无顾忌地使用fork()开启线程进行处理，那么很有可能导致系统开启过多的线程而严重影响性能。所有JDK提供了一个ForkJoinPool线程池，对于fork()方法并不急着开启线程，而是提交给ForkJoinPool线程池处理，以节省系统资源。

2、ForkJoinPool线程池

2.1、流程图

注：由于线程池的优化，提交的任务和线程数量并不是一对一的关系。在绝大多数情况，一个物理线程实际上是需要处理多个逻辑任务的。因此，每个线程必然需要拥有一个任务队列。因此在实际执行过程中，可能遇到这种情况：线程A已经把自己的任务都执行完成了，而线程B还有一堆任务等着处理，此时，线程A就会"帮助"线程B，从线程B的任务队列中拿一个任务过来处理，尽可能地达到平衡。如下图，显示了这种互相帮助的精神。值得注意的是，当线程师徒帮助别人时，总是从任务队列底部开始拿数据，而线程试图执行自己的任务时，则是从相反的顶部开始拿，因此这种行为有利于避免数据竞争。

2.2、ForkJoinPool重要的方法

/**
 * 参数中的ForkJoinTask任务就是支持fork()分解以及join()等待的任务
 * ForkJoinTask有两个重要的子类，RecuriveAction和RecuriveTask,分别表示没有返回值的任务和有返回值的任务。
 * @param task 待提交任务接口类
 * @return
 */
public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task)

2.3、图解

2.4、例子

2.4.1、示例一

package com.dsd.jdk.executor.forkjoin;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

/**
 * 有返回值的任务
 * @author daishengda
 *
 */
public class CountTask extends RecursiveTask<Long>{

    /**
     * 
     */
    private static final long serialVersionUID = -8569760326589318177L;
    
    private static final int THRESHOLD = 10000;
    
    private long start;
    
    private long end;

    public CountTask(long start, long end) {
        this.start = start;
        this.end = end;
    }

    /**
     * THRESHOLD设置了任务分解的规模，也就是需要求和的总数大于THRESHOLD个，那么任务就需要再次分解，否则可以直接执行，
     * 如果任务可以直接执行，那么直接进行求和并返回结果；否则，就对任务再次分解。
     * 每次分解是将原有任务划分成100个等规模的小任务，并使用fork()提交子任务。之后等待所有的子任务结束，并通过join()将结果求和。
     */
    @Override
    public Long compute() {
        long sum = 0;
        boolean canCompute = (end - start) < THRESHOLD;
        if(canCompute)
        {
            for (long i = start; i <= end; i++) {
                sum += i;
            }
        }
        else
        {
            //分成100个小任务
            long step = (start + end) / 100;
            List<CountTask> subTasks = new ArrayList<CountTask>();
            long pos = start;
            for (int i = 0; i < 100; i++) {
                long lastOne = pos+step;
                if(lastOne > end)
                    lastOne = end;
                CountTask subTask = new CountTask(pos, lastOne);
                pos += step+1;
                subTasks.add(subTask);
                subTask.fork();
            }
            for (CountTask t : subTasks) {
                sum += t.join();
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        /**
         * 构造一个计算1到200000求和的任务。将任务提交给线程池ForkJoinPool
         * 线程池会返回一个有返回值的任务
         */
        CountTask task = new CountTask(0L, 200000L);
        ForkJoinTask<Long> result = forkJoinPool.submit(task);
        try {
            //通过get()方法可以得到最终结果，如果任务没有结束，那么主线程就会在get()方法阻塞等待
            long res = result.get();
            System.out.println("sum="+res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

注：如果任务的划分层次很深，一直得不到返回，那么可能出现两种情况：

1、系统内的线程数量越积越多，导致性能严重下降

2、函数的调用层次变得很深，最终导致栈溢出

2.4.1、示例二

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;


/**
 * ForkJoin示例
 * 
 * @author tangyb
 * @date 2020年3月4日
 */
@Service
public class ForkJoinDemo extends RecursiveTask<String> {


    private static final long serialVersionUID = -8960189617811448549L;
    private static Logger logger = LoggerFactory.getLogger(ForkJoinDemo.class);
    private static final int THRESHOLD = 2; // 阈值
    private final List<String> dataList; // 要处理的内容

    private static AtomicInteger count = new AtomicInteger(0);

    public ForkJoinDemo(List<String> dataList) {
        // 构造方法创建主任务
        this.dataList = dataList;
    }

    @Override
    protected String compute() {
        // 数据大小
        int size = dataList.size();

        if (size <= THRESHOLD) {
            return transaction(); // 大小等于阈值顺序计算结果
        }

        // 第一个分组
        ForkJoinDemo ltTask = new ForkJoinDemo(dataList.subList(0, size / 2));
        // 第二个分组
        ForkJoinDemo rtTask = new ForkJoinDemo(dataList.subList(size / 2, size));

        // 两个任务并发执行起来
        invokeAll(ltTask, rtTask);

        // 读取第一个分组任务处理的结果
        String ltResult = ltTask.join();
        // 读取第二个分组任务处理的结果
        String rtResult = rtTask.join();

        // 返回处理结果
        return String.format("%s%s", rtResult, ltResult);
    }

    /**
     * 处理类
     * 
     * @return
     */
    public String transaction() {
        String msg = "";
        for (String data : dataList) {
            try {
                Thread.sleep(100);
                msg = msg + "," + data;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        logger.info(count.toString());
        count.getAndIncrement();
        // 在子任务中做处理
        return msg;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        List<String> list = new ArrayList<String>();
        for (long i = 1; i <= 50; i++) {
            list.add(String.valueOf(i));
        }
        ForkJoinTask<String> mainTask = new ForkJoinDemo(list);

        ForkJoinPool pool = new ForkJoinPool(4);

        // 1、execute() 是直接向池提交一个任务来异步执行，无返回结果。
        // pool.execute(mainTask);

        // 2、submit() 也是异步执行，但是会返回提交的任务，在适当的时候可通过 task.get() 获取执行结果。
        // ForkJoinTask<String> result = pool.submit(mainTask);
        // String msg = result.get();

        // 阻塞当前线程直到 ForkJoinPool 中所有的任务都执行结束
        // pool.awaitTermination(5, TimeUnit.SECONDS);

        // 3、invoke() 会等待任务计算完毕并返回计算结果。
        String msg = pool.invoke(mainTask);
        System.out.println("---------------" + msg);

        // 关闭线程池
        pool.shutdown();
    }
}

2.5、详细学习文档

参考：https://www.cnblogs.com/daishengda/p/8909524.html

湯神码

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Fork/Join：JDK并发包-线程池-分而治之

1、Fork/Join简介1.1、分而治之一个非常有效地处理大量数据的方法。著名的MapReduce也是采取分而治之的思想。简单来说，就是如果你要处理1000个数据，但是你并不具备处理1000个数据的能力，那么你可以只处理其中的10个，然后分阶段处理100次，将100次的结果进行合并，那就是最终想要的对原始1000个数据的处理结果。1.2、Fork/Join框架Java中通过使用fork(...
复制链接

扫一扫