前言
以前需要异步执行一个任务时,一般是用Thread或者线程池Executor去创建。如果需要返回值,则是调用Executor.submit获取Future。但是多个线程存在依赖组合,我们又能怎么办?可使用同步组件CountDownLatch、CyclicBarrier等;其实有简单的方法,就是用CompletableFuture线程任务的创建
线程任务的串行执行
线程任务的并行执行
处理任务结果和异常
多任务的简单组合
取消执行线程任务
任务结果的获取和完成与否判断
1、创建异步线程任务
根据supplier创建CompletableFuture任务
//使用内置线程ForkJoinPool.commonPool(),根据supplier构建执行任务public static CompletableFuture supplyAsync(Supplier supplier)//指定自定义线程,根据supplier构建执行任务public static CompletableFuture supplyAsync(Supplier supplier, Executor executor)
根据runnable创建CompletableFuture任务
//使用内置线程ForkJoinPool.commonPool(),根据runnable构建执行任务public static CompletableFuture runAsync(Runnable runnable)//指定自定义线程,根据runnable构建执行任务public static CompletableFuture runAsync(Runnable runnable, Executor executor)
使用示例
ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture rFuture = CompletableFuture .runAsync(() -> System.out.println("hello siting"), executor);//supplyAsync的使用CompletableFuture 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 CompletableFuture completedFuture(U value)
2 、线程串行执行
任务完成则运行action,不关心上一个任务的结果,无返回值
public CompletableFuture thenRun(Runnable action)public CompletableFuture thenRunAsync(Runnable action)public CompletableFuture thenRunAsync(Runnable action, Executor executor)
使用示例
CompletableFuture future = CompletableFuture .supplyAsync(() -> "hello siting", executor)
.thenRunAsync(() -> System.out.println("OK"), executor);executor.shutdown();--------输出结果--------OK
任务完成则运行action,依赖上一个任务的结果,无返回值
public CompletableFuture thenAccept(Consumer super T> action)public CompletableFuture thenAcceptAsync(Consumer super T> action)public CompletableFuture thenAcceptAsync(Consumer super T> action, Executor executor)
使用示例
ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture future = CompletableFuture .supplyAsync(() -> "hello siting", executor)
.thenAcceptAsync(System.out::println, executor);executor.shutdown();--------输出结果--------hello siting
任务完成则运行fn,依赖上一个任务的结果,有返回值
public CompletableFuture thenApply(Function super T,? extends U> fn)public CompletableFuture thenApplyAsync(Function super T,? extends U> fn) public CompletableFuture thenApplyAsync(Function super T,? extends U> fn, Executor executor)
使用示例
ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture future = CompletableFuture .supplyAsync(() -> "hello world", executor)
.thenApplyAsync(data -> {
System.out.println(data); return "OK";
}, executor);System.out.println(future.join());executor.shutdown();--------输出结果--------hello world
OK
thenCompose - 任务完成则运行fn,依赖上一个任务的结果,有返回值类似thenApply(区别是thenCompose的返回值是CompletionStage,thenApply则是返回 U),提供该方法为了和其他CompletableFuture任务更好地配套组合使用
public CompletableFuture thenCompose(Function super T, ? extends CompletionStage> fn) public CompletableFuture thenComposeAsync(Function super T, ? extends CompletionStage> fn)public CompletableFuture thenComposeAsync(Function super T, ? extends CompletionStage> fn,
Executor executor)
使用示例
//第一个异步任务,常量任务CompletableFuture f = CompletableFuture.completedFuture("OK");//第二个异步任务ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture future = CompletableFuture .supplyAsync(() -> "hello world", executor)
.thenComposeAsync(data -> {
System.out.println(data); return f; //使用第一个任务作为返回
}, executor);System.out.println(future.join());executor.shutdown();--------输出结果--------hello world
OK
3 、线程并行执行
两个CompletableFuture并行执行完,然后执行action,不依赖上两个任务的结果,无返回值
public CompletableFuture runAfterBoth(CompletionStage> other, Runnable action)public CompletableFuture runAfterBothAsync(CompletionStage> other, Runnable action)public CompletableFuture runAfterBothAsync(CompletionStage> other, Runnable action, Executor executor)
使用示例
//第一个异步任务,常量任务CompletableFuture first = CompletableFuture.completedFuture("hello world");ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture 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 CompletableFuture thenAcceptBoth(CompletionStage extends U> other,
BiConsumer super T, ? super U> action)//两个任务异步完成,fn再依赖消费两个任务的结果,无返回值public CompletableFuture thenAcceptBothAsync(CompletionStage extends U> other,
BiConsumer super T, ? super U> action) //两个任务异步完成(第二个任务用指定线程池执行),fn再依赖消费两个任务的结果,无返回值public CompletableFuture thenAcceptBothAsync(CompletionStage extends U> other,
BiConsumer super T, ? super U> action, Executor executor)
使用示例
//第一个异步任务,常量任务CompletableFuture first = CompletableFuture.completedFuture("hello world");ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture 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 CompletableFuture thenCombine(CompletionStage extends U> other,
BiFunction super T,? super U,? extends V> fn)//两个任务异步完成,fn再依赖消费两个任务的结果,有返回值public CompletableFuture thenCombineAsync(CompletionStage extends U> other,
BiFunction super T,? super U,? extends V> fn) //两个任务异步完成(第二个任务用指定线程池执行),fn再依赖消费两个任务的结果,有返回值public CompletableFuture thenCombineAsync(CompletionStage extends U> other,
BiFunction super T,? super U,? extends V> fn, Executor executor)
使用示例
//第一个异步任务,常量任务CompletableFuture first = CompletableFuture.completedFuture("hello world");ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture 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 siting
OK
4 、线程并行执行,谁先执行完则谁触发下一任务(二者选其最快)
上一个任务或者other任务完成, 运行action,不依赖前一任务的结果,无返回值
public CompletableFuture runAfterEither(CompletionStage> other, Runnable action) public CompletableFuture runAfterEitherAsync(CompletionStage> other, Runnable action)public CompletableFuture runAfterEitherAsync(CompletionStage> other,
Runnable action, Executor executor)
使用示例
//第一个异步任务,休眠1秒,保证最晚执行晚CompletableFuture first = CompletableFuture.supplyAsync(()->{
try{ Thread.sleep(1000); }catch (Exception e){}
System.out.println("hello world");
return "hello world";});ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture 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 siting
OK
上一个任务或者other任务完成, 运行action,依赖最先完成任务的结果,无返回值
public CompletableFuture acceptEither(CompletionStage extends T> other,
Consumer super T> action)public CompletableFuture acceptEitherAsync(CompletionStage extends T> other,
Consumer super T> action, Executor executor) public CompletableFuture acceptEitherAsync(CompletionStage extends T> other,
Consumer super T> action, Executor executor)
使用示例
//第一个异步任务,休眠1秒,保证最晚执行晚CompletableFuture first = CompletableFuture.supplyAsync(()->{
try{ Thread.sleep(1000); }catch (Exception e){}
return "hello world";});ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture 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 CompletableFuture applyToEither(CompletionStage extends T> other,
Function super T, U> fn) public CompletableFuture applyToEitherAsync(CompletionStage extends T> other,
Function super T, U> fn) public CompletableFuture applyToEitherAsync(CompletionStage extends T> other,
Function super T, U> fn, Executor executor)
使用示例
//第一个异步任务,休眠1秒,保证最晚执行晚CompletableFuture first = CompletableFuture.supplyAsync(()->{
try{ Thread.sleep(1000); }catch (Exception e){}
return "hello world";});ExecutorService executor = Executors.newSingleThreadExecutor();CompletableFuture 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 siting
OK
5 、处理任务结果或者异常
exceptionally-处理异常
public CompletableFuture exceptionally(Function fn)
如果之前的处理环节有异常问题,则会触发exceptionally的调用相当于 try...catch
使用示例
CompletableFuture 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 CompletableFuture handle(BiFunction super T, Throwable, ? extends U> fn) public CompletableFuture handleAsync(BiFunction super T, Throwable, ? extends U> fn) public CompletableFuture handleAsync(BiFunction super T, Throwable, ? extends U> fn,
Executor executor)
使用示例
CompletableFuture 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 whenComplete(BiConsumer super T, ? super Throwable> action) public CompletableFuture whenCompleteAsync(BiConsumer super T, ? super Throwable> action) public CompletableFuture whenCompleteAsync(BiConsumer super T, ? super Throwable> action,
Executor executor)
使用示例
CompletableFuture 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 allOf(CompletableFuture>... cfs)public static CompletableFuture anyOf(CompletableFuture>... cfs)
使用示例
CompletableFuture future = CompletableFuture .allOf(CompletableFuture.completedFuture("A"),
CompletableFuture.completedFuture("B"));//全部任务都需要执行完future.join();CompletableFuture future2 = CompletableFuture .anyOf(CompletableFuture.completedFuture("C"),
CompletableFuture.completedFuture("D"));//其中一个任务行完即可future2.join();
7、取消执行线程任务
// mayInterruptIfRunning 无影响;如果任务未完成,则返回异常public boolean cancel(boolean mayInterruptIfRunning) //任务是否取消public boolean isCancelled()
使用示例
CompletableFuture 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.CancellationException
at 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 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。
欢迎大家一起交流,喜欢文章记得关注我点赞哟,感谢支持!