CompletableFuture简介与使用

CompletableFuture

这个completableFuture是JDK1.8版本新引入的类。下面是这个类。实现了俩接口。本身是个class。这个是Future的实现类。
使用completionStage接口去支持完成时触发的函数和操作。
一个completetableFuture就代表了一个任务。他能用Future的方法。还能做一些之前说的executorService配合futures做不了的。
之前future需要等待isDone为true才能知道任务跑完了。或者就是用get方法调用的时候会出现阻塞。而使用completableFuture的使用就可以用then，when等等操作来防止以上的阻塞和轮询isDone的现象出现

那就先介绍一下Future和Callable借口
代码:

public class FutureDemo {
    public static void main(String[] args) throws Exception {
        // 创建实现了Callable接口的实例
        CallableDemo callableDemo = new CallableDemo();
        // 于实现了Future接口的实现类 来接收返回的结果  我们一般用FutureTask
        FutureTask<Integer> futureTask = new FutureTask<>(callableDemo);
        // 运行该线程
        new Thread(futureTask).start();
        // 获取结果
        // 有两种方式
        // 1. get
        /*
         *  如果线程没有执行完结果
         *  这里会出现阻塞
         */
        Integer integer = futureTask.get();
        System.out.println("integer = " + integer);

        // -----------------------我是华丽的分割线----------------------

        // 2.isDone
        // 创建实现了Callable接口的实例
        CallableDemo callableDemo1 = new CallableDemo();
        // 于实现了Future接口的实现类 来接收返回的结果  我们一般用FutureTask
        FutureTask<Integer> futureTask1 = new FutureTask<>(callableDemo1);
        // 运行该线程
        new Thread(futureTask1).start();
        // 判读线程
        while (!futureTask.isDone()) {
            TimeUnit.SECONDS.sleep(1);
        }
        Integer integer1 = futureTask.get();
        System.out.println("integer = " + integer1);

    }
}

/**
 * 1. 实现Callable可以很值一个泛型 这个泛型就是方法的返回值 并且这个方法可以抛出异常
 * 2. 执行callable方式 需要FutureTask实现类 支持  用于接收运算结果  FutureTask是 Future接口的实现类
 */
class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

CompletableFuture: 相比上面的方法不需要轮循 或 阻塞 在异步方法执行完成 再去执行另一个方法
总结一下优点:
·异步任务结束时,会自动回调某个对象的方法
·异步任务出错时,会自动回调某个对象的方法
·主线程设置好回调后,不再关心异步任务的执行

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建一个CompletableFuture   CompletableFuture.supplyAsync异步的 他的参数是一个 Supplier函数式借口 提供一个子任务
        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
                int i = 10 / 0;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "执行完成 lamdba 执行完成";
        });

        // 子任务执行成功 回调给方法 参数是一个 Consumer的 函数式接口
        cf.thenAccept(result -> {
            System.out.println("子任务执行成功");
            System.out.println("result = " + result);
        });

        // 子任务执行成功失败 回调这个方法  参数是一个 Function<Throwable, ? extends T>函数式借口
        cf.exceptionally(e -> {
            System.out.println("e = " + e.getMessage());
            return "子任务执行成功失败";
        });
        cf.join();
    }

穿行执行多个CompletableFuture

   public static void main(String[] args) throws Exception {
        // 创建一个CompletableFuture   CompletableFuture.supplyAsync异步的 他的参数是一个 Supplier函数式借口 提供一个子任务
        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "执行完成 lamdba 执行完成 一号";
        });

        CompletableFuture<String> cf1 = cf.thenApplyAsync((result) -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return result + " | 执行完成 lamdba 执行完成 二号";
        });

        // 子任务执行成功 回调给方法 参数是一个 Consumer的 函数式接口
        cf1.thenAccept(result -> {
            System.out.println("子任务执行成功");
            System.out.println("result = " + result);
        });
        cf1.join();
    }

并行执行多个CompletableFuture
anyOf
连个必须都执行成功 一个执行失败就 执行exceptionally 方法 哪一个先执行成功 使用哪一个

    public static void main(String[] args) throws Exception {

        // 创建一个CompletableFuture   CompletableFuture.supplyAsync异步的 他的参数是一个 Supplier函数式借口 提供一个子任务
        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return "执行完成 lamdba 执行完成 一号";
        });

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(0);
                int i = 10 / 0;
            } catch (InterruptedException e) {
                throw new RuntimeException("");

            }
            return " | 执行完成 lamdba 执行完成 二号";
        });
        CompletableFuture<Object> cf2 = CompletableFuture.anyOf(cf, cf1);

        // 子任务执行成功 回调给方法 参数是一个 Consumer的 函数式接口
        cf2.thenAccept(result -> {
            System.out.println("子任务执行成功");
            System.out.println("result = " + result);
        });
        // 子任务执行成功失败 回调这个方法  参数是一个 Function<Throwable, ? extends T>函数式借口
        cf2.exceptionally(e -> {
            System.out.println("e = " + e.getMessage());
            throw new RuntimeException("出现异常了");
        });
        cf2.join();
    }

allOf
连个必须都执行成功 一个执行失败就 执行exceptionally 方法
最后的CompletableFuture 的泛型必须是 Void

  public static void main(String[] args) throws Exception {

        // 创建一个CompletableFuture   CompletableFuture.supplyAsync异步的 他的参数是一个 Supplier函数式借口 提供一个子任务
        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return "执行完成 lamdba 执行完成 一号";
        });

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(0);
            } catch (InterruptedException e) {
                throw new RuntimeException("");

            }
            return " | 执行完成 lamdba 执行完成 二号";
        });
        //
        CompletableFuture<Void> cf2 = CompletableFuture.allOf(cf, cf1);

        // 子任务执行成功 回调给方法 参数是一个 Consumer的 函数式接口
        cf2.thenAccept(result -> {
            System.out.println("子任务执行成功");
            System.out.println("result = " + result);
        });
        // 子任务执行成功失败 回调这个方法  参数是一个 Function<Throwable, ? extends T>函数式借口
        cf2.exceptionally(e -> {
            System.out.println("e = " + e.getMessage());
            throw new RuntimeException("出现异常了");
        });
        cf2.join();
    }

CompletableFuture的命名规则:
xxx():继续在已有的线程中执行
xxxAsync():Executor的新线程执行

CompletableFuture对象可以指定异步处理流程:
thenAccept()处理正常结果
exceptional()处理异常结果
thenApplyAsync()用于串行化另一个CompletableFuture
anyOf / allOf用于并行化两个CompletableFuture