zoukankan      html  css  js  c++  java
  • 基础篇:异步编程不会?我教你啊!CompletableFuture

    前言

    以前需要异步执行一个任务时,一般是用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 无返回值,输出null
    System.out.println(rFuture.join());
    //阻塞等待
    String name = future.join();
    System.out.println(name);
    executor.shutdown(); // 线程池需要关闭
    --------输出结果--------
    hello siting
    null
    hello siting
    

    常量值作为CompletableFuture返回

    //有时候是需要构建一个常量的CompletableFuture
    public 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 world
    OK
    

    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 world
    OK
    

    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 siting
    OK
    

    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 siting
    OK
    

    上一个任务或者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 siting
    OK
    

    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 more
    null
    

    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
    任务取消后:true
    java.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)
    //未完成则返回指定value
    public T getNow(T valueIfAbsent)
    //未完成,使用value作为任务执行的结果,任务结束。需要future.get获取
    public boolean complete(T value)
    //未完成,则是异常调用,返回异常结果,任务结束
    public boolean completeExceptionally(Throwable ex)
    //判断任务是否因发生异常结束的
    public boolean isCompletedExceptionally()
    //强制地将返回值设置为value,无论该之前任务是否完成;类似complete
    public void obtrudeValue(T value)
    //强制地让异常抛出,异常返回,无论该之前任务是否完成;类似completeExceptionally
    public 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
    

    欢迎指正文中错误

  • 相关阅读:
    3123123weq
    123132w
    Unable to execute dex: Multiple dex files define 解决方法
    Error: leaving XXXX; does not track upstream.
    repo sync error: .repo/manifests/: contains uncommitted changes
    Can't OPEN Eclipse
    ERROR: Current shell is not /bin/bash, please check. Stop.
    GIT_ERROR: gpg: Can't check signature: public key not found error: could not verify the tag 'v1.12.4'
    GIT_Error: Agent admitted failure to sign —— Permission denied (publickey).
    HTTP 与 SOAP 介绍与关系
  • 原文地址:https://www.cnblogs.com/cscw/p/14089958.html
Copyright © 2011-2022 走看看