Fork/Join分支合并框架、异步回调——JUC随记9

1、概述

从JDK1.7开始，Java提供Fork/Join框架用于并行执行任务，它的思想就是讲一个大任务分割成若干小任务，最终汇总每个小任务的结果得到这个大任务的结果。
这种思想和MapReduce很像（input --> split --> map --> reduce --> output）
主要有两步：
第一、任务切分；
第二、结果合并；

2、示例

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

public class ForkJoinDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        MyTask myTask=new MyTask(0,100);
        //创建分支合并池对象
        ForkJoinPool forkJoinPool=new ForkJoinPool();
        ForkJoinTask<Integer> submit = forkJoinPool.submit(myTask);
        Integer result = submit.get();

        System.out.println(result);

        //关闭
        forkJoinPool.shutdown();
    }
}


//创建一个资源类
class MyTask extends RecursiveTask<Integer>{

    //拆分差值不能超过10，计算10以内运算
    private static final Integer VALUE = 10;
    private int begin ;//拆分开 始值
    private int end;//拆分结束值
    private int result ; //返 回结果.

    //创建有参构造
    public MyTask(int begin,int end) {
        this.begin=begin;
        this.end=end;
    }

    @Override
    protected Integer compute() {
        if((end-begin)>10){
            for (int i=begin;i<=end;i++){
                result+=i;
            }
        }else {
            MyTask myTaskLeft = new MyTask(begin, (begin + end) / 2);
            myTaskLeft.fork();
            MyTask myTaskRight = new MyTask( (begin + end) / 2,end);
            myTaskRight.fork();

            //合并结果
            result=myTaskLeft.join()+myTaskRight.join();
        }
        return result;
    }
}

3、异步会调

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //异步回调没有返回值
        CompletableFuture<Void> completableFuture1= CompletableFuture.runAsync(()->{
            System.out.println(Thread.currentThread().getName()+":completableFuture1");
        });

        completableFuture1.get();

        //异步回调有返回值
        CompletableFuture<Integer> completableFuture2=CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+":completableFuture2");
            int i=1/0;
            return 1024;
        });

        completableFuture2.whenComplete((t,u)->{
            System.out.println("t="+t);//方法的返回值
            System.out.println("u="+u);//获取异常信息
        }).get();
    }
}