CompletableFuture用法详解

apply方法和handle方法一样，都是结束计算之后的后续操作，唯一的不同是，handle方法会给出异常，可以让用户自己在内部处理，而apply方法只有一个返回结果，如果异常了，会被直接抛出，交给上一层处理。 如果不想每个链式调用都处理异常，那么就使用apply吧

计算完成的后续操作4——accept

public CompletableFuture  thenAccept(Consumersuper T> action)
public CompletableFuture  thenAcceptAsync(Consumersuper T> action)
public CompletableFuture  thenAcceptAsync(Consumersuper T> action, Executor executor)

accept（）三个方法只做最终结果的消费，注意此时返回的CompletableFuture是空返回。只消费，无返回，有点像流式编程的终端操作

捕获中间产生的异常——exceptionally

public CompletableFuture exceptionally(Function fn)

exceptionally() 可以帮我们捕捉到所有中间过程的异常，方法会给我们一个异常作为参数，我们可以处理这个异常，同时返回一个默认值，跟服务降级 有点像，默认值的类型和上一个操作的返回值相同

CompletableFuture future = CompletableFuture.supplyAsync(() -> {
      // 返回null
      return null;
});
 
CompletableFuture exceptionally = future.thenApply(result -> {
     // 制造一个空指针异常NPE
     int i = result;
     return i;
}).exceptionally(error -> {
     // 我们选择在这里打印出异常
     error.printStackTrace();
     // 并且当异常发生的时候，我们返回一个默认的值
     return "发生了异常";
});

组合两个completableFuture

thenApply()

将两个异步计算合并为一个，这两个异步计算之间相互独立，同时第二个又依赖于第一个的结果

CompletableFuture> future = CompletableFuture.supplyAsync(() -> {
    // 根据学生姓名获取学生信息
    return StudentService.getStudent(name);
}).thenApply(student -> {
    // 再根据学生信息获取今天的课程
     return LessonsService.getLessons(student);
});

thenCombine(）

将两个异步计算合并为一个，这两个异步计算之间相互独立，互不依赖

CompletableFuture> painting = CompletableFuture.supplyAsync(() -> {
     // 第一个任务获取美术课需要带的东西，返回一个list
     List stuff = new ArrayList<>();
     stuff.add("画笔");
     stuff.add("颜料");
     return stuff;
});
CompletableFuture> handWork = CompletableFuture.supplyAsync(() -> {
     // 第二个任务获取劳技课需要带的东西，返回一个list
     List stuff = new ArrayList<>();
     stuff.add("剪刀");
     stuff.add("折纸");
     return stuff;
});
CompletableFuture> total = painting
     // 传入handWork列表，然后得到两个CompletableFuture的参数Stuff1和2
     .thenCombine(handWork, (stuff1, stuff2) -> {
     // 合并成新的list
     List totalStuff = Stream.of(stuff1, stuff1)
         .flatMap(Collection::stream)
         .collect(Collectors.toList());
     return totalStuff;
});

获取所有完成结果——allOf

当所有给定的任务完成后，返回一个全新的已完成CompletableFuture

final ExecutorService executorService = Executors.newFixedThreadPool(100);
 
List futures = Lists.newArrayList();
 
futures.add(CompletableFuture.runAsync(() -> {
		   // do something
        },executorService).thenRunAsync(() -> {
		  long end = System.currentTimeMillis();
		  log.info("combine.combine.time2:{}",(end - start));
		},executorService));
 
futures.add(CompletableFuture.runAsync(() -> {
		   // do something
        },executorService).thenRunAsync(() -> {
		  long end = System.currentTimeMillis();
		  log.info("combine.combine.time2:{}",(end - start));
		},executorService));
 
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).thenRun(() -> {
	long end = System.currentTimeMillis();
	log.info("combine.combine.time3:{}",(end - start));
}).join();

获取率先完成的任务结果——anyOf

仅等待Future集合种最快结束的任务完成（有可能因为他们试图通过不同的方式计算同一个值），并返回它的结果。 小贴士 ：如果最快完成的任务出现了异常，也会先返回异常，如果害怕出错可以加个exceptionally() 去处理一下可能发生的异常并设定默认返回值

CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
      return 1;
});
 
CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
      return 2;
});
 
CompletableFuture