CompletableFuture的使用介绍, CompletableFuture与FutureTask的区别

        CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。

        总的来说简洁了FutureTask与线程池的配合使用

        没啥太大区别吧我觉得, 使用方法不一样, 多了一些方法 ???

futureTask 创建异步任务

        FutureTask<String> stringFutureTask = new FutureTask<>(() -> {             return "aa";         });         executorService.execute(stringFutureTask);         System.out.println(stringFutureTask.get());          CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {             return "aa";         }, executorService); // 不用手动提交了         System.out.println(future1.get());

 还有很多异步回调, 组合处理

创建任务

1. .supplyAsync

 创建一个带返回值的任务

 2. .runAsync

 创建一个不带返回值的任务

        ExecutorService executorService = Executors.newFixedThreadPool(1);          // 带返回值         CompletableFuture future = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println("future　" + new Date());                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return "aaa";         }, executorService); // 推荐使用

 以上两个方法都有两个构造方法, 默认不指定自定义线程池, 他会指定默认的提交任务的方法

    // 查看cpu的核数是否大于1核     private static final boolean useCommonPool =         (ForkJoinPool.getCommonPoolParallelism() > 1);      // 如果大于1核 则调用execute方法, 每次创建一个线程     private static final Executor asyncPool = useCommonPool ?         ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();      static final class ThreadPerTaskExecutor implements Executor {         public void execute(Runnable r) { new Thread(r).start(); }     }

所以推荐自定义线程池的方式

异步回调

指的是 异步任务结束后调用的任务

1. .thenApply

带返回值的异步调用函数, 有入参, 有出参

2. .thenAccept

 不带返回值的异步回调函数, 有入参

         CompletableFuture future = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println("future　" + new Date());                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return "aaa";         }, executorService);          // future执行完之后执行的异步任务         CompletableFuture<String> thenApply = future.thenApply((result) -> {             System.out.println("future2　" +new Date());             System.out.println(result);             return "bbb" + result;         });

3. .exceptionally

异步任务出现异常调用的回调方法

        CompletableFuture future = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println("future　" + new Date());                 Thread.sleep(2000);                 int a = 1 / 0;             } catch (InterruptedException e) {                 e.printStackTrace();             }             return "aaa";         }, executorService);          CompletableFuture<String> exceptionally = future.exceptionally((result) -> {             System.out.println("future3 " + result);             return "bbb" + result;         });                  // 出现异常则返回异常, 没异常则返回future的返回值         System.out.println(exceptionally.get());

 去掉异常

4. .whenComplete

 当主任务出现异常时, 会终止任务,get的时候会抛出主任务的异常,  入参值为null, 否则正常运行

        CompletableFuture future = CompletableFuture.supplyAsync(() -> {             try {                 System.out.println("future　" + new Date());                 Thread.sleep(2000);                 int a = 1/0;             } catch (InterruptedException e) {                 e.printStackTrace();             }             return "aaa";         }, executorService);          CompletableFuture<String> exceptionally = future.whenComplete((result, error) -> {             System.out.println("future3 " + result);             System.out.println("future3 " + error);         });         System.out.println(exceptionally.get());

 去掉异常

组合处理

....

就是将多个任务组合起来执行, 时间原因, 这里我就不介绍了, 大家另行百度吧