Fork/Join 框架

Fork/Join 它可以将一个大的任务拆分成多个子任务进行并行处理，最后将子任务结果合并成最后的计算结果，并进行输出。Fork/Join 框架要完成两件事情：

Fork：把一个复杂任务进行分拆，大事化小
Join：把分拆任务的结果进行合并

案例

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() {
        //判断两个两个相加的值是否大于10
        if (end - begin <= VALUE){
            //相加操作
            for (int i = begin; i <= end; i++) {
                result = result+i;
            }
        }else {//进一步拆分
            //获取中间值
            int mid = (begin+end)/2;
            //拆分左边
            MyTask myTask01 = new MyTask(begin, mid);
            //拆分右边
            MyTask myTask02 = new MyTask(mid + 1, end);
            myTask01.fork();
            myTask02.fork();

            result = myTask01.join() + myTask02.join();
        }
        return result;
    }
}
public class ForkJoinDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建MyTask对象
        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();
    }
}

异步回调

异步和同步的区别

一、传输单位不同

1、异步：异步传输是以字符为传输单位，每个字符都要附加 1 位起始位和 1 位停止位，以标记一个字符的开始和结束，并以此实现数据传输同步。

2、同步：同步传输是以数据块为传输单位。每个数据块的头部和尾部都要附加一个特殊的字符或比特序列，标记一个数据块的开始和束，一般还要附加一个校验序列(如16位或32位CRC校验码)，以便对数据块进行差错控制。

二、含义不同

1、异步：发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。

2、同步：发送方发出数据后，等接收方发回响应以后才发下一个数据包的通讯方式。

三、模式不同

1、异步：异步是非阻塞模式。

2、同步：同步是阻塞模式。

案例

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 = 1024/0;
            return 1024;
        });
        completableFuture2.whenComplete((t,u)->{
            System.out.println("t======="+t);//返回值
            System.out.println("u======="+u);//方法中的异常信息
        }).get();
    }
}