CompletableFuture对象

最新推荐文章于 2024-11-19 23:59:14 发布
最新推荐文章于 2024-11-19 23:59:14 发布
阅读量287 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： 数据库 python java
原文链接：https://my.oschina.net/u/2277632/blog/1592701
本文详细介绍了Java 8中引入的CompletableFuture类，通过丰富的示例代码展示了如何使用CompletableFuture实现异步编程，包括创建、组合任务及处理异常等多种场景。

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

java8中加入了这个CompletableFuture对象，据说用起来会比较爽，Stream和CompletableFuture的设计都遵循了类似的模式:它们都使用了Lambda表达式以及流水线的思想。看oracle给出的说明，对于下面这样的查询数据库的操作

175158_bHyP_2277632.png

但是假设查询的数据库操作比较慢，我们想另起一个线程去执行，等执行完成的时候，打印出来结果，以前我们可以使用Callable，用ExcutorService执行。

175355_rdSv_2277632.png

151253_2Dcw_2277632.png

但是这里有个问题是，当调用future的get()方法获取结果，但是会阻塞当前调用的线程;它很难直接表述多个Future 结果之间的依赖性，实际开发中，我们经常需要达成这种目的，原来的Future接口的方法并不多。CompletionStage就应运而生了，然后我们重写上面的执行方法：

180446_1cs4_2277632.png

用CompletableFuture（实现了CompletionStage接口）的supplyAsync()方法取代了ExecutorService的submit()，而且可以把Executor作为第二个参数，提供执行的线程池的选择，没有阻塞当前线程。当然CompletableFuture也实现了Future接口，所以也同样可以使用get进行阻塞获取值。task可以是正在运行，或者已经完成返回结果，或者异常。

182144_SwGo_2277632.png

创建一个已完成的CompletableFuture，看起来很奇怪，为什么这么写，据说对于用于测试环境是很有用的，暴露不太写单元测试了。

193809_NDGu_2277632.png

从task创建一个CompletableFuture，这里有两种方式从一个Runnable或者supplier，当然还有第二参数是线程池的方法，runAsync()易于理解，注意它需要Runnable，因此它返回CompletableFuture<Void>作为Runnable不返回任何值。如果你需要处理异步操作并返回结果，使用Supplier<U>194014_1KBi_2277632.png

如果没有提供ExecutorService，会使用fork/join pool框架执行，这种方式也用于streams的并行操作，后续我们写的demo也是类似。关键的入参只有一个Function，它是函数式接口，所以使用Lambda表示起来会更加优雅。task可以是Function,Consumer或者Runnable。

public static void useWithThread() throws Exception{
        CompletableFuture<Integer> completableFuture = new CompletableFuture();
        new Thread(new Runnable() {
            @Override
            public void run() {
                //模拟执行耗时任务
                System.out.println("task doing...");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //告诉completableFuture任务已经完成
                System.out.println(Thread.currentThread());
                completableFuture.complete(121);
            }
        }).start();
        System.out.println(Thread.currentThread());
        //获取任务结果，如果没有完成会一直阻塞等待
        //如果发生异常 会被限制在执行任务的线程的范围内，最终会杀死该线程，而这会导致等待 get 方法返回结果的线程永久地被阻塞。
        //客户端可以使用重载版本的 get 方法，它使用一个超时参数来避免发生这样的情况
        Integer result=completableFuture.get();
        //使用这种方法至少能防止程序永久地等待下去，超时发生时，程序会得到通知发生了 Timeout-Exception 。
        // 不过，也因为如此，你不能指定执行任务的线程内到底发生了什么问题。
//        Integer result=completableFuture.get(100, TimeUnit.SECONDS);
        System.out.println("计算结果:"+result);
    }

    public static void useWithThreadCompleteException() throws Exception{
        CompletableFuture<String> completableFuture=new CompletableFuture();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //模拟执行耗时任务
                    System.out.println("task doing...");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    throw new RuntimeException("抛异常了");
                }catch (Exception e) {
                    //告诉completableFuture任务发生异常了
                    completableFuture.completeExceptionally(e);
                }
            }
        }).start();

        String result=completableFuture.get(5, TimeUnit.SECONDS);
        System.out.println("计算结果:"+result);
    }

    public static void useExceptionally() {
        String result = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (1 == 1) {
                throw new RuntimeException("测试一下异常情况");
            }
            return "s1";
        }).exceptionally(e -> {
            System.out.println(e.toString());
            return "hello world";
        }).join();
        System.out.println(result);
    }


    /**
     *方法接受一个生产者（Supplier）作为参数，返回一个 CompletableFuture
     对象。生产者方法会交由 ForkJoinPool池中的某个执行线程（ Executor ）运行，
       但是你也可以使用 supplyAsync 方法的重载版本，传递第二个参数指定线程池执行器执行生产者方法。
     * @throws Exception
     */
    public static void usesupplyAsync() throws Exception {
        //supplyAsync内部使用ForkJoinPool线程池执行任务
        CompletableFuture<String> completableFuture=CompletableFuture.supplyAsync(()->{
            //模拟执行耗时任务
            System.out.println("task doing...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //返回结果
            return "hello xin";
        });
        System.out.println("计算结果:"+completableFuture.get(5, TimeUnit.SECONDS));
    }

    public static void useAnyofAndAllof() throws Exception {

        CompletableFuture<String> completableFuture1=CompletableFuture.supplyAsync(()->{
            //模拟执行耗时任务
            System.out.println("task1 doing...");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //返回结果
            System.out.println(Thread.currentThread());
            return "hello";
        });

        CompletableFuture<String> completableFuture2=CompletableFuture.supplyAsync(()->{
            //模拟执行耗时任务
            System.out.println("task2 doing...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //返回结果
            System.out.println(Thread.currentThread());
            return "world";
        });

        /**
         * 该方法接收一个 CompletableFuture 对象构成的数组，返回由第一个执行完毕的
         * CompletableFuture 对象的返回值构成的 CompletableFuture<Object>
         */
        CompletableFuture<Object> anyResult=CompletableFuture.anyOf(completableFuture1,completableFuture2);

        System.out.println("第一个完成的任务结果:"+anyResult.get());

        //allOf 工厂方法接收一个由CompletableFuture 构成的数组，数组中的所有
        // Completable-Future 对象执行完成之后，它返回一个 CompletableFuture<Void> 对象。
        // 这意味着，如果你需要等待多个 CompletableFuture 对象执行完毕，对 allOf 方法返回的
        //CompletableFuture 执行 join 操作可以等待CompletableFuture执行完成

        CompletableFuture<Void> allResult=CompletableFuture.allOf(completableFuture1,completableFuture2);

        //阻塞等待所有任务执行完成
        allResult.join();
        System.out.println("所有任务执行完成");

    }

    /**
     * //等第一个任务完成后，将任务结果传给参数result，执行后面的任务并返回一个代表任务的completableFuture
     * @throws Exception
     */
    public static void useThenCompose() throws Exception {

        CompletableFuture<String> completableFuture1=CompletableFuture.supplyAsync(()->{
            //模拟执行耗时任务
            System.out.println("task1 doing...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //返回结果
            return "hello";
        }).thenCompose(result->CompletableFuture.supplyAsync(()->{
            //模拟执行耗时任务
            System.out.println("task2 doing...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //返回结果
            return result+" world";
        }));

        System.out.println(completableFuture1.get(10,TimeUnit.SECONDS));

    }

    /**
     *  public <U,V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
        public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
        public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn,Executor executor);
     * 将第一个任务与第二个任务组合一起执行，都执行完成后，将两个任务的结果合并
     * @throws Exception
     */
    public static void useThenCombine() throws Exception {

        CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            //模拟执行耗时任务
            System.out.println("task1 doing...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //返回结果
            return 100;
        }).thenCombine(
                //第二个任务
                CompletableFuture.supplyAsync(() -> {
                    //模拟执行耗时任务
                    System.out.println("task2 doing...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //返回结果
                    return 200;
                }),
                //合并函数
                (result1, result2) -> result1 + result2);

        System.out.println(completableFuture1.get(10,TimeUnit.SECONDS));

    }

    public static void usethenAccept() throws Exception {

        CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            //模拟执行耗时任务
            System.out.println("task1 doing...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //返回结果
            return 100;
        });

        //注册完成事件
        completableFuture1.thenAccept(result->System.out.println("task1 done,result:"+result));

        CompletableFuture<Integer> completableFuture2=
                //第二个任务
                CompletableFuture.supplyAsync(() -> {
                    //模拟执行耗时任务
                    System.out.println("task2 doing...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //返回结果
                    return 2000;
                });

        //注册完成事件
        completableFuture2.thenAccept(result->System.out.println("task2 done,result:"+result));

        //将第一个任务与第二个任务组合一起执行，都执行完成后，将两个任务的结果合并
        CompletableFuture<Integer> completableFuture3 = completableFuture1.thenCombine(completableFuture2,
                //合并函数
                (result1, result2) -> {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return result1 + result2;
                });

        System.out.println(completableFuture3.get());

    }

    /**
     * public <U> CompletionStage<U> thenApply(Function<? super T,? extends U> fn);
       public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn);
       public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn,Executor executor);
     */
    public static void useThenApply() {
        String result = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread());
            return "hello";}
            ).thenApplyAsync(s -> { System.out.println(Thread.currentThread());return s + " world";}).join();
        System.out.println(result);
    }

    /**
     *public CompletionStage<Void> thenAccept(Consumer<? super T> action);
     public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
     public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor);
     */
    public static void useThenAccept(){
        CompletableFuture.supplyAsync(() -> "hello").thenAccept(s -> System.out.println(s+" world"));
    }

    /**
     *public CompletionStage<Void> thenRun(Runnable action);
     public CompletionStage<Void> thenRunAsync(Runnable action);
     public CompletionStage<Void> thenRunAsync(Runnable action,Executor executor);
     */
    public static void useThenRun() throws ExecutionException, InterruptedException {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread());
            return "hello";
        }).thenRun(() -> {
            System.out.println(" world");
            System.out.println(Thread.currentThread());
        }).get();


    }

/*  public <U> CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
    public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
    public public<U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action,     Executor executor);
*/
    public static void useThenAcceptBoth() throws ExecutionException, InterruptedException {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        }).thenAcceptBoth(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "world";
        }), (s1, s2) -> System.out.println(s1 + " " + s2)).get();

    }

/*
    public CompletionStage<Void> runAfterBoth(CompletionStage<?> other,Runnable action);
    public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action);
    public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor executor);
*/
    public static void useRunAfterBoth() throws ExecutionException, InterruptedException {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "s1";
        }).runAfterBothAsync(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "s2";
        }), () -> System.out.println("hello world")).get();

    }

  /*  public <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn);
    public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn);
    public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn,Executor executor);
  */
  public static void useApplyToEither() {
      String result = CompletableFuture.supplyAsync(() -> {
          try {
              Thread.sleep(3000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          return "s1";
      }).applyToEither(CompletableFuture.supplyAsync(() -> {
          try {
              Thread.sleep(2000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          return "hello world";
      }), s -> s).join();
      System.out.println(result);
  }
/*

    public CompletionStage<Void> acceptEither(CompletionStage<? extends T> other,Consumer<? super T> action);
    public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action);
    public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action,Executor executor);
*/
    public static void useAcceptEither() {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "s1";
        }).acceptEither(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello world";
        }), System.out::println);
        while (true){}
    }
/*

    public CompletionStage<Void> runAfterEither(CompletionStage<?> other,Runnable action);
    public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action);
    public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor);
*/
    public static void useRunAfterEither() {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "s1";
        }).runAfterEither(CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "s2";
        }), () -> System.out.println("hello world"));
        while (true) {
        }
    }

    /**
     * public CompletionStage<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
     public CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
     public CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor);
     当运行完成时，对结果的记录。这里的完成时有两种情况，一种是正常执行，返回值。
     另外一种是遇到异常抛出造成程序的中断。这里为什么要说成记录，
     因为这几个方法都会返回CompletableFuture，当Action执行完毕后它的结果返回原始的CompletableFuture的计算结果或者返回异常。
     所以不会对结果产生任何的作用
     */

    public static void useWhenComplete() {
        String result = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (1 == 1) {
                throw new RuntimeException("测试一下异常情况");
            }
            return "s1";
        }).whenComplete((s, t) -> {
            System.out.println(s);
            System.out.println(t.getMessage());
        }).exceptionally(e -> {
            System.out.println(e.getMessage());
            return "hello world";
        }).join();
        System.out.println(result);
    }
/*

    public <U> CompletionStage<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
    public <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn);
    public <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn,Executor executor);
*/

    public static void handle() {
        String result = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //出现异常
            if (1 == 1) {
                throw new RuntimeException("测试一下异常情况");
            }
            return "s1";
        }).handle((s, t) -> {
            if (t != null) {
                return "hello world";
            }
            return s;
        }).join();
        System.out.println(result);
    }

写的代码也在https://github.com/woshiyexinjie/java-godliness

参考内容：

http://www.jianshu.com/p/6f3ee90ab7d3

http://www.jianshu.com/p/4897ccdcb278

转载于:https://my.oschina.net/u/2277632/blog/1592701

Java中的异步编程：使用CompletableFuture
AI天才研究院
07-19 3251
作者：禅与计算机程序设计艺术 在Java中进行异步编程一直是一种困难甚至不可能的事情。由于各种历史原因、一些被遗忘的实现细节、线程池等问题导致了编写异步代码的困难和复杂性。最近的OpenJDK版本引入了一个新特性——CompletableFuture，它提供了一个全新的并发模型——Reactive Streams，用于编写响应式异步流处理
CompletableFuture创建异步对象
a203206868的博客
08-20 227
CompletableFuture 提供了四个静态方法来创建一个异步操作。 public static CompletableFuture<Void> runAsync(Runnable runnable)； public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)； public static <U> CompletableFuture<U> su
CompletableFuture 相关用法
sekever的博客
07-20 592
由于guava中Listenablefuture的成功，在Java8中，设计师们也新加了一个包含50个方法左右的类CompletableFuture。它的优点就是异步编程，同时这个类的使用也相当抽象…非常抽象。
CompletableFuture异步线程
weixin_45205175的博客
07-28 350
CompletableFuture异步线程
CompletableFuture 异步编排的简单使用
学习总结
03-30 1038
如果在我们的业务中某些功能需要其他一些功能执行完成之后才能开始执行（比如获取其他功能的返回结果），这样就需要用到异步编排功能。Future 是 Java 5 添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel方法停止任务的执行。虽然Future以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。
CompletableFuture使用，举例说明
weixin_45716265的博客
05-27 524
一、基本使用，创建异步对象 runXxx都是没有返回结果的，supplyXxx都是可以获取返回结果的。 可以传入自定义线程池，否则就用默认的线程池 @Test public void ThreadTest1() throws ExecutionException, InterruptedException { System.out.println("main............start............"); CompletableFuture.runA
CompletableFuture对象进行异步操作，
05-23
3. 如果需要在多个CompletableFuture对象完成后执行某个操作，可以使用thenCombine、thenAcceptBoth或runAfterBoth等方法来组合多个CompletableFuture对象。 4. 如果需要捕获异步操作中发生的异常，可以使用...
如何创建一个可见的 CompletableFuture 对象？
09-24
要创建一个可见的 CompletableFuture 对象，你可以使用 CompletableFuture 类提供的静态方法之一或者直接使用其构造函数。下面是两种常用的方法： 1. 使用 CompletableFuture 的静态方法 supplyAsync，它接受一个 ...
CompletableFuture回调机制的设计与实现
最新发布
张彦峰的博客
11-19 5万+
CompletableFuture回调机制的设计与实现：首先分析Future原理总述与局限性，再次分析CompletableFuture原理与回调机制总结，最后从类图分析、整体流程分析和算法实现分析CompletableFuture回调机制设计，结尾给出简单的使用CompletableFuture注意方面
Java 异步编程——异步编排(CompletableFuture)
longool的博客
10-21 2090
CompletableFuture 是 JDK8 提出的一个支持非阻塞的多功能的 Future，提供了一种强大的异步编程模型，实现了 Future 接口；在使用 Future 的过程中，大家会发现 Future 有两种方式返回结果的方式CompletableFuture 接口提供了非常多的方法用于编排异步任务，基本每个方法都有两套实现，Async 版本的函数与非 Async 版本的函数。
CompletableFuture 基本用法
qq_44286009的博客
06-22 2743
是 Java 8 引入的一个功能强大的类，用于异步编程和并发处理。它提供了丰富的 API 来处理异步任务的结果，支持函数式编程风格，并允许通过链式调用组合多个异步操作。
Java 异步编程的完美利器：CompletableFuture 指北
半亩方塘立身
01-16 1523
Future获取异步执行结果，但是缺乏异步回调机制，只能阻塞式获取结果。CompletableFuture 是 Java 平台提供的一个用于处理异步编程的类，用于简化异步编程、并发处理以及异步任务的组合。
CompletableFuture简单用法
2401_85480529的博客
07-18 416
是 Java 8 引入的一种用于处理异步编程的类。它提供了多种方法，允许我们以非阻塞的方式编写并发代码。用于需要返回结果的异步任务，而。用于不需要返回结果的异步任务。
学习使用CompletableFuture
Ason Blogs
07-23 321
CompletableFuture一．前言1．JDK5的异步处理方式2．JDK8的异步处理方式二、学习CompletableFuture1．结果获取方式2．创建CompletableFuture对象3．CompletableFuture 的异步回调功能：thenApply4．运行完成时的代码，即对结果进行消耗：thenAccept5．上一步结果与下一步操作无关系：thenRun6．对2个cf的结果进行组合：thenCompose7．结合2个cf的结果：thenCombine8．消耗两个cf的结果，不返回结果
java8 -CompletableFuture
zhanghua850127的专栏
09-03 638
新颖的、优雅的异步处理数据的方法 Java SE 8为Java平台带来了许多新东西，其中很多已经在生产环境当中得到了应用。但是在异步编程方法，却并不是每个程序员都能很好的使用，也并非所有应用程序都使用java.util.concurrent包，即使此包中对于编写正确的并发代码提供的原语非常有用。 java.util.concurrent包在Java 8中增加了几个非常好的补充接口和实现类。我们在本...
一文搞懂CompletableFuture的使用
weixin_45987961的博客
01-24 4528
前言 创建线程的方式只有两种：继承Thread或者实现Runnable接口。 但是这两种方法都存在一个缺陷，没有返回值 Java 1.5 以后，可以通过向线程池提交一个Callable来获取一个包含返回值的Future对象 Future接口的局限性 当Future的线程进行了一个非常耗时的操作，那我们的主线程也就阻塞了。 当我们在简单业务上，可以使用Future的另一个重载方法get(long,TimeUnit)来设置超时时间，避免我们的主线程被无穷尽地阻塞。 单纯使用Future接口或者Fut
CompletableFuture详解
weixin_43527947的博客
08-06 1万+
在JAVA8开始引入了全新的类，它是Future接口的一个实现类。也就是在Future接口的基础上，额外封装提供了一些执行方法，用来解决Future使用场景中的一些不足，对流水线处理能力提供了支持。当我们需要进行异步处理的时候，我们可以通过方法，传入一个具体的要执行的处理逻辑函数，这样就轻松的完成了CompletableFuture的创建与触发执行。方法名称作用描述静态方法，用于构建一个对象，并异步执行传入的参数，允许执行函数有返回值runAsync静态方法，用于构建一个。
CompletableFuture详细介绍及方法使用示例(一)
Ascend1977的博客
05-25 9453
CompletableFuture是Java 8中引入的一种实现异步编程模型的方式，它是Future的扩展，提供了更强大、更灵活的功能。CompletableFuture可以表示两个异步任务之间的顺序关系或并行关系，同时提供了一些方便的工具方法来组合这些关系。
CompletableFuture使用详解（全网看这一篇就行）
热门推荐
搬砖老农工的博客
04-02 10万+
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 1. supplyAsync supplyAsync是带有返回值的异步任务。它有如下两个方法，有一个是带有线程池的重载方法 // 带返回值异步请求，默认线程池 public static <U> Completa
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值