前言

以前需要异步执行一个任务时，一般是用Thread或者线程池Executor去创建。如果需要返回值，则是调用Executor.submit获取Future。但是多个线程存在依赖组合，我们又能怎么办？可使用同步组件CountDownLatch、CyclicBarrier等；其实有简单的方法，就是用CompletableFuture

线程任务的创建
线程任务的串行执行
线程任务的并行执行
处理任务结果和异常
多任务的简单组合
取消执行线程任务
任务结果的获取和完成与否判断

1、创建异步线程任务

根据supplier创建CompletableFuture任务

//使用内置线程ForkJoinPool.commonPool()，根据supplier构建执行任务public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)//指定自定义线程，根据supplier构建执行任务public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

根据runnable创建CompletableFuture任务

//使用内置线程ForkJoinPool.commonPool()，根据runnable构建执行任务public static CompletableFuture<Void> runAsync(Runnable runnable)//指定自定义线程，根据runnable构建执行任务public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)

使用示例

ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<Void> rFuture = CompletableFuture.runAsync(() -> System.out.println(\"hello siting\"), executor);//supplyAsync的使用CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {System.out.print(\"hello \");return \"siting\";}, executor);//阻塞等待，runAsync 的future 无返回值，输出nullSystem.out.println(rFuture.join());//阻塞等待String name = future.join();System.out.println(name);executor.shutdown(); // 线程池需要关闭--------输出结果--------hello sitingnullhello siting

常量值作为CompletableFuture返回

//有时候是需要构建一个常量的CompletableFuturepublic static <U> CompletableFuture<U> completedFuture(U value)

2 、线程串行执行

任务完成则运行action，不关心上一个任务的结果，无返回值

public CompletableFuture<Void> thenRun(Runnable action)public CompletableFuture<Void> thenRunAsync(Runnable action)public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor)

使用示例

CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> \"hello siting\", executor).thenRunAsync(() -> System.out.println(\"OK\"), executor);executor.shutdown();--------输出结果--------OK

任务完成则运行action，依赖上一个任务的结果，无返回值

public CompletableFuture<Void> thenAccept(Consumer<? super T> action)public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action)public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor)

使用示例

ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> \"hello siting\", executor).thenAcceptAsync(System.out::println, executor);executor.shutdown();--------输出结果--------hello siting

任务完成则运行fn，依赖上一个任务的结果，有返回值

public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn)public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)

使用示例

ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> \"hello world\", executor).thenApplyAsync(data -> {System.out.println(data); return \"OK\";}, executor);System.out.println(future.join());executor.shutdown();--------输出结果--------hello worldOK

thenCompose – 任务完成则运行fn，依赖上一个任务的结果，有返回值

类似thenApply（区别是thenCompose的返回值是CompletionStage，thenApply则是返回 U），提供该方法为了和其他CompletableFuture任务更好地配套组合使用

public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn)public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn)public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn,Executor executor)

使用示例

//第一个异步任务，常量任务CompletableFuture<String> f = CompletableFuture.completedFuture(\"OK\");//第二个异步任务ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> \"hello world\", executor).thenComposeAsync(data -> {System.out.println(data); return f; //使用第一个任务作为返回}, executor);System.out.println(future.join());executor.shutdown();--------输出结果--------hello worldOK

3 、线程并行执行

两个CompletableFuture[并行]执行完，然后执行action，不依赖上两个任务的结果，无返回值

public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other, Runnable action)public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action)public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor)

使用示例

//第一个异步任务，常量任务CompletableFuture<String> first = CompletableFuture.completedFuture(\"hello world\");ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<Void> future = CompletableFuture//第二个异步任务.supplyAsync(() -> \"hello siting\", executor)// () -> System.out.println(\"OK\") 是第三个任务.runAfterBothAsync(first, () -> System.out.println(\"OK\"), executor);executor.shutdown();--------输出结果--------OK

两个CompletableFuture[并行]执行完，然后执行action，依赖上两个任务的结果，无返回值

//第一个任务完成再运行other，fn再依赖消费两个任务的结果，无返回值public <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action)//两个任务异步完成，fn再依赖消费两个任务的结果，无返回值public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action)//两个任务异步完成（第二个任务用指定线程池执行），fn再依赖消费两个任务的结果，无返回值public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action, Executor executor)

使用示例

//第一个异步任务，常量任务CompletableFuture<String> first = CompletableFuture.completedFuture(\"hello world\");ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<Void> future = CompletableFuture//第二个异步任务.supplyAsync(() -> \"hello siting\", executor)// (w, s) -> System.out.println(s) 是第三个任务.thenAcceptBothAsync(first, (s, w) -> System.out.println(s), executor);executor.shutdown();--------输出结果--------hello siting

两个CompletableFuture[并行]执行完，然后执行action，依赖上两个任务的结果，有返回值

//第一个任务完成再运行other，fn再依赖消费两个任务的结果，有返回值public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn)//两个任务异步完成，fn再依赖消费两个任务的结果，有返回值public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn)//两个任务异步完成（第二个任务用指定线程池执行），fn再依赖消费两个任务的结果，有返回值public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn, Executor executor)

使用示例

//第一个异步任务，常量任务CompletableFuture<String> first = CompletableFuture.completedFuture(\"hello world\");ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<String> future = CompletableFuture//第二个异步任务.supplyAsync(() -> \"hello siting\", executor)// (w, s) -> System.out.println(s) 是第三个任务.thenCombineAsync(first, (s, w) -> {System.out.println(s);return \"OK\";}, executor);System.out.println(future.join());executor.shutdown();--------输出结果--------hello sitingOK

4 、线程并行执行，谁先执行完则谁触发下一任务（二者选其最快）

上一个任务或者other任务完成, 运行action，不依赖前一任务的结果，无返回值

public CompletableFuture<Void> runAfterEither(CompletionStage<?> other, Runnable action)public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action)public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action, Executor executor)

使用示例

//第一个异步任务，休眠1秒，保证最晚执行晚CompletableFuture<String> first = CompletableFuture.supplyAsync(()->{try{ Thread.sleep(1000); }catch (Exception e){}System.out.println(\"hello world\");return \"hello world\";});ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<Void> future = CompletableFuture//第二个异步任务.supplyAsync(() ->{System.out.println(\"hello siting\");return \"hello siting\";} , executor)//() ->  System.out.println(\"OK\") 是第三个任务.runAfterEitherAsync(first, () ->  System.out.println(\"OK\") , executor);executor.shutdown();--------输出结果--------hello sitingOK

上一个任务或者other任务完成, 运行action，依赖最先完成任务的结果，无返回值

public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other,Consumer<? super T> action)public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action, Executor executor)public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action, Executor executor)

使用示例

//第一个异步任务，休眠1秒，保证最晚执行晚CompletableFuture<String> first = CompletableFuture.supplyAsync(()->{try{ Thread.sleep(1000);  }catch (Exception e){}return \"hello world\";});ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<Void> future = CompletableFuture//第二个异步任务.supplyAsync(() -> \"hello siting\", executor)// data ->  System.out.println(data) 是第三个任务.acceptEitherAsync(first, data ->  System.out.println(data) , executor);executor.shutdown();--------输出结果--------hello siting

上一个任务或者other任务完成, 运行fn，依赖最先完成任务的结果，有返回值

public <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn)public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn)public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn, Executor executor)

使用示例

//第一个异步任务，休眠1秒，保证最晚执行晚CompletableFuture<String> first = CompletableFuture.supplyAsync(()->{try{ Thread.sleep(1000);  }catch (Exception e){}return \"hello world\";});ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture<String> future = CompletableFuture//第二个异步任务.supplyAsync(() -> \"hello siting\", executor)// data ->  System.out.println(data) 是第三个任务.applyToEitherAsync(first, data ->  {System.out.println(data);return \"OK\";} , executor);System.out.println(future);executor.shutdown();--------输出结果--------hello sitingOK

5 、处理任务结果或者异常

exceptionally-处理异常

public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)

如果之前的处理环节有异常问题，则会触发exceptionally的调用相当于 try…catch
使用示例

CompletableFuture<Integer> first = CompletableFuture.supplyAsync(() -> {if (true) {throw new RuntimeException(\"main error!\");}return \"hello world\";}).thenApply(data -> 1).exceptionally(e -> {e.printStackTrace(); // 异常捕捉处理，前面两个处理环节的日常都能捕获return 0;});

handle-任务完成或者异常时运行fn，返回值为fn的返回

相比exceptionally而言，即可处理上一环节的异常也可以处理其正常返回值

public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn)public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn)public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn,Executor executor)

使用示例

CompletableFuture<Integer> first = CompletableFuture.supplyAsync(() -> {if (true) { throw new RuntimeException(\"main error!\"); }return \"hello world\";}).thenApply(data -> 1).handleAsync((data,e) -> {e.printStackTrace(); // 异常捕捉处理return data;});System.out.println(first.join());--------输出结果--------java.util.concurrent.CompletionException: java.lang.RuntimeException: main error!... 5 morenull

whenComplete-任务完成或者异常时运行action，有返回值

whenComplete与handle的区别在于，它不参与返回结果的处理，把它当成监听器即可
即使异常被处理，在CompletableFuture外层，异常也会再次复现
使用whenCompleteAsync时，返回结果则需要考虑多线程操作问题，毕竟会出现两个线程同时操作一个结果

public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action)public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action)public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor)

使用示例

CompletableFuture<AtomicBoolean> first = CompletableFuture.supplyAsync(() -> {if (true) {  throw new RuntimeException(\"main error!\"); }return \"hello world\";}).thenApply(data -> new AtomicBoolean(false)).whenCompleteAsync((data,e) -> {//异常捕捉处理, 但是异常还是会在外层复现System.out.println(e.getMessage());});first.join();--------输出结果--------java.lang.RuntimeException: main error!Exception in thread \"main\" java.util.concurrent.CompletionException: java.lang.RuntimeException: main error!... 5 more

6 、多个任务的简单组合

public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

使用示例

CompletableFuture<Void> future = CompletableFuture.allOf(CompletableFuture.completedFuture(\"A\"),CompletableFuture.completedFuture(\"B\"));//全部任务都需要执行完future.join();CompletableFuture<Object> future2 = CompletableFuture.anyOf(CompletableFuture.completedFuture(\"C\"),CompletableFuture.completedFuture(\"D\"));//其中一个任务行完即可future2.join();

7、取消执行线程任务

// mayInterruptIfRunning 无影响；如果任务未完成,则返回异常public boolean cancel(boolean mayInterruptIfRunning)//任务是否取消public boolean isCancelled()

使用示例

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {try { Thread.sleep(1000);  } catch (Exception e) { }return \"hello world\";}).thenApply(data -> 1);System.out.println(\"任务取消前:\" + future.isCancelled());// 如果任务未完成,则返回异常,需要对使用exceptionally，handle 对结果处理future.cancel(true);System.out.println(\"任务取消后:\" + future.isCancelled());future = future.exceptionally(e -> {e.printStackTrace();return 0;});System.out.println(future.join());--------输出结果--------任务取消前:false任务取消后:truejava.util.concurrent.CancellationExceptionat java.util.concurrent.CompletableFuture.cancel(CompletableFuture.java:2276)at Test.main(Test.java:25)0

8、任务的获取和完成与否判断

// 任务是否执行完成public boolean isDone()//阻塞等待 获取返回值public T join()// 阻塞等待 获取返回值,区别是get需要返回受检异常public T get()//等待阻塞一段时间，并获取返回值public T get(long timeout, TimeUnit unit)//未完成则返回指定valuepublic T getNow(T valueIfAbsent)//未完成，使用value作为任务执行的结果，任务结束。需要future.get获取public boolean complete(T value)//未完成，则是异常调用,返回异常结果，任务结束public boolean completeExceptionally(Throwable ex)//判断任务是否因发生异常结束的public boolean isCompletedExceptionally()//强制地将返回值设置为value，无论该之前任务是否完成；类似completepublic void obtrudeValue(T value)//强制地让异常抛出，异常返回，无论该之前任务是否完成；类似completeExceptionallypublic void obtrudeException(Throwable ex)

使用示例

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {try { Thread.sleep(1000);  } catch (Exception e) { }return \"hello world\";}).thenApply(data -> 1);System.out.println(\"任务完成前:\" + future.isDone());future.complete(10);System.out.println(\"任务完成后:\" + future.join());--------输出结果--------任务完成前:false任务完成后:10

总结

Java 多线程一直是面试时候的重点，也是能力提升的重要体现，如何做到波澜不惊，从容面对，需要我们对其中的内容融汇贯通，小编这里也对应总结了一份多线程-并发编程的思维导图，需要的朋友可以看看，关注公众号：麒麟改bug，还可以领取一份包含了Java基础、Java集合容器、Java异常、并发编程、JVM、Spring、Spring MVC、Spring Boot、Spring Cloud、MyBatis、Redis、MySQL数据库、消息中间件MQ与RabbitMQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty、架构设计&分布式&数据结构与算法等等，都是互联网大厂的面试真题，已经有粉丝靠这份PDF拿下众多大厂的offer。

Java后端开发三年多线程你都懂，问你异步编程你说你没听过？？？

前言