ForkJoin有参无返回值、有参有返回值实例

介绍：

　　a . Fork/Join为JKD1.7引入，适用于对大量数据进行拆分成多个小任务进行计算的框架，最后把所有小任务的结果汇总合并得到最终的结果

　　b . 相关类

public abstract class RecursiveTask<V> extends ForkJoinTask<V>;
public abstract class RecursiveAction extends ForkJoinTask<Void>;

　　c . 其中RecursiveTask在执行有返回值的任务时使用，RecursiveAction在执行没有返回值的任务时使用

实例代码：

　　ForkJoin有参无返回值

　　参数：map

public class UpdatePlayersTotalTimeTask extends RecursiveAction {

    private static final int THRESHOLD_NUM = 30;//定义任务的切分阀值
    private Map<String,String> players;
    private PlayerTotalTimeService playerTotalTimeService;
    private MongoDao mongoDao;

    public UpdatePlayersTotalTimeTask(Map<String,String> players, MongoDao mongoDao) {
        this.players = players;
        this.mongoDao = mongoDao;
    }

    @Override
    protected void compute() {
        boolean canCompute = players.size() <= THRESHOLD_NUM;
        if (canCompute) {
            playerTotalTimeService = new PlayerTotalTimeService();
            playerTotalTimeService.updatePlayersTotalTime(players, mongoDao);
        } else {
　　　　　　　// 将任务一份为二
            int middle = players.size() / 2;

            int i = 0;
            Map<String, String> leftMap = new HashMap<>();
            Map<String, String> rightMap = new HashMap<>();

            for (Map.Entry<String, String> entry : players.entrySet()) {
                if (i < middle) {
                    leftMap.put(entry.getKey(), entry.getValue());
                } else {
                    rightMap.put(entry.getKey(), entry.getValue());
                }
                i++;
            }

            UpdatePlayersTotalTimeTask leftTask = new UpdatePlayersTotalTimeTask(leftMap, mongoDao);
            UpdatePlayersTotalTimeTask rightTask = new UpdatePlayersTotalTimeTask(rightMap, mongoDao);

            // 执行子任务
            leftTask.fork();
            rightTask.fork();
        }
    }

　　//调用测试
    public static void main(String[] args) throws InterruptedException {
        // 创建包含Runtime.getRuntime().availableProcessors()返回值作为个数的并行线程的ForkJoinPool
        ForkJoinPool forkjoinPool = new ForkJoinPool();

        Map<String, String> map = new HashMap<>();
　　　　 map.put("key1","value1");
        MongoDao mongoDao = new MongoDaoImpl();
        //生成一个计算任务
        UpdatePlayersTotalTimeTask task = new UpdatePlayersTotalTimeTask(map, mongoDao);
        // 提交可分解的PrintTask任务
        forkjoinPool.excute(task);
        forkjoinPool.awaitTermination(2, TimeUnit.SECONDS);//阻塞当前线程直到 ForkJoinPool 中所有的任务都执行结束
        // 关闭线程池
        forkjoinPool.shutdown();
    }

}

　　ForkJoin有参有返回值        (继承RecursiveTask<T>类)

　　参数：set<String>   返回值：map<String,String>

 public class CalcRoomPlayersTotalTimeTask extends RecursiveTask<Map<String,String>> {
     private static final int THRESHOLD_NUM = 15;
     private Set<String> roomSet;
     private PlayerTotalTimeService playerTotalTimeService;
     private MongoDao mongoDao;

     public CalcRoomPlayersTotalTimeTask(Set<String> roomSet, MongoDao mongoDao) {
         this.roomSet = roomSet;
         this.mongoDao = mongoDao;
     }

     @Override
     protected Map<String,String> compute() {

         playerTotalTimeService = new PlayerTotalTimeService();
         //如果任务足够小就计算任务
         boolean canCompute = roomSet.size() <= THRESHOLD_NUM;
         if (canCompute) {

             Map<String,String> playersResult = new HashMap<>();

             playersResult =  playerTotalTimeService.calcRoomPlayersTotalTime(roomSet, mongoDao);

             return playersResult;
         } else {
             // 如果任务大于阈值，就分裂成两个子任务计算
             long middle = roomSet.size() / 2;
             Set<String> leftSet = new HashSet<>();
             Set<String> rightSet = new HashSet<>();

             long i = 0;
             for (String room : roomSet) {
                 if (i < middle) {
                     leftSet.add(room);
                 } else {
                     rightSet.add(room);
                 }
                 i++;
             }

             CalcRoomPlayersTotalTimeTask leftTask = new CalcRoomPlayersTotalTimeTask(leftSet,mongoDao);
             CalcRoomPlayersTotalTimeTask rightTask = new CalcRoomPlayersTotalTimeTask(rightSet,mongoDao);

             // 执行子任务
             invokeAll(leftTask,rightTask);

             HashMap<String,String> result = new HashMap<>();

             Map<String,String> leftResult = leftTask.join();
             Map<String,String> rightResult = rightTask.join();

             result.putAll(leftResult);

             for (Map.Entry<String, String> entry : rightResult.entrySet()) {
                 boolean contains = result.containsKey(entry.getKey());
                 if(contains){
                     String playerTotalTimeStr =  entry.getValue();
                     Long playerTotalTimeLong = playerTotalTimeService.timeStringToLong(result.get(entry.getKey()))  + playerTotalTimeService.timeStringToLong(playerTotalTimeStr);
                     playerTotalTimeStr = playerTotalTimeService.timeLongToString(playerTotalTimeLong);
                     result.put(entry.getKey(),playerTotalTimeStr);
                 }else {
                     result.put(entry.getKey(),entry.getValue());
                 }
             }

             return result;
         }
     }

     public static void main(String[] args) throws InterruptedException {
         // 创建包含Runtime.getRuntime().availableProcessors()返回值作为个数的并行线程的ForkJoinPool
         ForkJoinPool forkjoinPool = new ForkJoinPool();

         Set<String> roomSet = new HashSet<>();
         Map<String,String> map = new HashMap<String,String>();
         MongoDao mongoDao = new MongoDaoImpl();
         //生成一个计算任务
         CalcRoomPlayersTotalTimeTask task = new CalcRoomPlayersTotalTimeTask(roomSet, mongoDao);

         // 提交可分解的PrintTask任务         
　　　　　　 map = forkjoinPool.invoke(task);
         forkjoinPool.awaitTermination(2, TimeUnit.SECONDS);//阻塞当前线程直到 ForkJoinPool 中所有的任务都执行结束
         // 关闭线程池
         forkjoinPool.shutdown();
     }
 }    

说明：

　　a .在有大量计算任务时，此框架方法可进行并行计算效率高，以上示例，可以根据具体的业务需求更改属性及相关方法用于匹配自己的业务逻辑

b .JDK1.8后由于加入Stream流的操作,集合框架可以使用Collection<E> default Stream<E> parallelStream()的方法转换成并行流进行计算，此时效果与Fork/Join任务同效

c .ForkJoinPool中的多种方法

 public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task);//等待获取结果
 public void execute(ForkJoinTask<?> task);//异步执行
 public <T> T invoke(ForkJoinTask<T> task);//执行,获取Future

d .ForkJoinTask在执行的时候可能会抛出异常，但是没办法在主线程里直接捕获异常，所以ForkJoinTask提供了isCompletedAbnormally()方法来检查任务是否已经抛出异常或已经被取消了，并且可以通过ForkJoinTask的getException方法获取异常。getException方             法返回Throwable对象，如果任务被取消了则返回CancellationException。如果任务没有完成或者没有抛出异常则返回null。

if(task.isCompletedAbnormally()) {
    System.out.println(task.getException());
}

注：部分内容引自https://segmentfault.com/a/1190000010209196