博客
关于我
基础篇:异步编程不会?我教你啊!CompletableFuture
阅读量:419 次
发布时间:2019-03-06

本文共 15104 字,大约阅读时间需要 50 分钟。

前言

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

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

关注公众号,一起交流,微信搜一搜: 潜行前行

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)//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)//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)    //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并行完成后执行action,action再依赖消费两个任务的结果,无返回值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并行执行完,然后执行fn,依赖上两个任务的结果,有返回值

//调用方任务和other并行完成后,执行fn,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)//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)       //action用指定线程池执行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)         //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();

8 取消执行线程任务

// 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.CancellationException	at java.util.concurrent.CompletableFuture.cancel(CompletableFuture.java:2276)	at Test.main(Test.java:25)0

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

// 任务是否执行完成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

欢迎指正文中错误

转载地址:http://irgkz.baihongyu.com/

你可能感兴趣的文章
Manjaro 24.1 “Xahea” 发布!具有 KDE Plasma 6.1.5、GNOME 46 和最新的内核增强功能
查看>>
mapping文件目录生成修改
查看>>
MapReduce程序依赖的jar包
查看>>
mariadb multi-source replication(mariadb多主复制)
查看>>
MariaDB的简单使用
查看>>
MaterialForm对tab页进行隐藏
查看>>
Member var and Static var.
查看>>
memcached高速缓存学习笔记001---memcached介绍和安装以及基本使用
查看>>
memcached高速缓存学习笔记003---利用JAVA程序操作memcached crud操作
查看>>
Memcached:Node.js 高性能缓存解决方案
查看>>
memcache、redis原理对比
查看>>
memset初始化高维数组为-1/0
查看>>
Metasploit CGI网关接口渗透测试实战
查看>>
Metasploit Web服务器渗透测试实战
查看>>
MFC模态对话框和非模态对话框
查看>>
Moment.js常见用法总结
查看>>
MongoDB出现Error parsing command line: unrecognised option ‘--fork‘ 的解决方法
查看>>
mxGraph改变图形大小重置overlay位置
查看>>
MongoDB可视化客户端管理工具之NoSQLbooster4mongo
查看>>
Mongodb学习总结(1)——常用NoSql数据库比较
查看>>