java8 CompletableFuture入门 使用教程 详解所有方法 附实例

最新推荐文章于 2024-05-29 22:55:19 发布
最新推荐文章于 2024-05-29 22:55:19 发布
阅读量1.1k 收藏 6
点赞数
文章标签： java
原文链接：https://my.oschina.net/u/3244997/blog/2248986
版权

概览

  1. CompletableFuture是java8引入的新类，该类实现了 Future 接口和 CompletionStage 接口，封装了future、forkjoin相关类来执行异步，所以你还是可以像以前一样通过阻塞(get)或者轮询的方式获得结果，尽管这种方式不推荐使用。
  2. CompletionStage 接口代表异步计算中的 不同阶段，以及如何 组合 这些计算阶段。
  3. CompletableStage 接口中有 50 多个方法，可以对 CompletableStage 进行组合、计算，方法看似很多，但可以按功能对其分类，大多数方法都有 3 种变体：
    1. 不带 Async 方法：同步方法
    2. 带 Async，只有一个参数：异步方法，使用默认的 ForkJoinPool.commonPool() 获取线程池
    3. 带 Async，有两个参数：异步方法，且使用第二个参数指定的 ExecutorService 线程池

了解CompletableFuture需要理解java8的函数式接口，不了解的同学可以先移步：https://my.oschina.net/u/3244997/blog/3014977

创建CompletableFuture对象

//比较特殊，他入参就是返回值，也就是说他可以用来执行需要其他返回值的异步任务。
public static <U> CompletableFuture<U> completedFuture(U value)

//无返回值，使用默认线程池
public static CompletableFuture<Void> 	runAsync(Runnable runnable)

//无返回值，使用自定义线程池
public static CompletableFuture<Void> 	runAsync(Runnable runnable, Executor executor)

//有返回值，使用默认线程池
public static <U> CompletableFuture<U> 	supplyAsync(Supplier<U> supplier)

//有返回值，使用自定义线程池
public static <U> CompletableFuture<U> 	supplyAsync(Supplier<U> supplier, Executor executor)

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

举例：

//supplyAsync方法无入参，但是返回一个String对象。此方法使用了默认的线程池执行异步任务
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    //长时间的计算任务
    return "·00";
});

在创建完CompletableFuture对象并且执行任务之后，还可以对结果或者异常等进行额外的操作或任务

下面将通过具体例子来展示各个方法的使用。

1.whenComplete* 和 exceptionally 方法

当原始的CompletableFuture任务执行完后，不管是否成功计算出结果，还是抛出异常，都会会执行 whenComplete* 或 exceptionally 的方法中的任务。
该操作执行完毕后：

  • 会返回一个新的CompletableFuture对象！！！
  • 使用whenComplete*方法时，返回的新的CompletableFuture对象的返回结果和原始的CompletableFuture对象计算结果相同
  • 使用 exceptionally方法时，如果原始计算逻辑抛出异常，那么返回的 新的CompletableFuture对象 的返回结果由该方法的return值决定；如果原始计算逻辑没有抛出异常，那么返回的 新的CompletableFuture对象 的返回结果和原始计算逻辑返回的结果一致。有点绕，先不明白没关系，下面会有四个exceptionally实例解释这段话。
BiConsumer<T,U> 函数接口有两个参数，无返回值。
Function<T,R> 函数接口有一个输入参数，返回一个结果。

//无Async，同步处理正常计算结果或异常，使用执行任务的那个线程来执行该方法，所以这个方法是同步的。
public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action)
//有Async，异步处理正常计算结果或异常，使用执行任务的那个线程池中的线程来执行该方法！所以这个方法是异步的。
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)
//有Async，异步处理正常计算结果或异常，使用自定义线程池来执行该方法，所以这个方法是异步的。
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? superThrowable> action, Executor executor)
//处理异常。
public CompletableFuture<T> exceptionally(Function<Throwable,? extends T> fn)

注意：当没有异常抛出来的时候，上面的Throwable参数为空！

举例：
计算逻辑：
    private static Random random = new Random();
    private static long time = System.currentTimeMillis();

    public static int getMoreData(){
        System.out.println("begin to start compute");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("end to compute, passed:" + System.currentTimeMillis());
        return random.nextInt(1000);
    }

    public static int throwException(){
        System.out.println("准备抛出异常");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("抛了");
        throw new RuntimeException("主动抛出异常");
    }

whenComplete：

    //如果使用这段代码，则会是和当前线程同步执行
    public static void main(String[] args) throws Exception{
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> getMoreData());

        CompletableFuture<Integer> future2 = future.whenComplete((result, excetion) -> {
            System.out.println("执行到whenComplete了，result:" + result);
            System.out.println("执行到whenComplete了，exception:" + (excetion == null ? "无异常" : excetion.getClass()));
        });
        System.out.println("执行到最后一段代码了，future result：" + future.get());
        System.out.println("执行到最后一段代码了，future2 result：" + future2.get());
    }

> 打印执行结果：  
begin to start compute  
end to compute, passed:1551182552193  
执行到whenComplete了，result:625  
执行到whenComplete了，exception:无异常  
执行到最后一段代码了，future result：625  
执行到最后一段代码了，future2 result：625  

>从打印结果可知，whenComplete使用原始的执行的任务的线程，所以可以看成是同步执行的，并且新的CompletableFuture对象的结果和原始的一致

whenCompleteAsync：

    //如果使用这段代码，则会是和当前线程同步执行
    public static void main(String[] args) throws Exception{
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> getMoreData());

        future.whenCompleteAsync((result, exception) -> {
            System.out.println("计算已执行完毕，result:" + result);
            System.out.println("计算已执行完毕，exception:" + (excetion == null ? "无异常" : excetion.getClass()));
        });
        System.out.println("执行到最后一段代码了，result：" + future.get());
    }

> 打印执行结果：  
begin to start compute  
end to compute, passed:1551180611064  
执行到最后一段代码了，result：323  
执行到whenComplete了，result:323  
执行到whenComplete了，exception:无异常  

>从打印结果可知，whenCompleteAsync是异步执行的

exceptionally比较复杂，需要通过4个实例才能真正明白：

exceptionally实例1：

    //这段代码，由于会抛出异常，会先走whenCompleteAsync，然后再走exceptionally，而且是无法获取到返回值的。
    public static void main(String[] args) throws Exception{

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> throwException());

        future.whenCompleteAsync((result, exception) -> {
            System.out.println("计算已执行完毕，result:" + result);
            System.out.println("计算已执行完毕，exception:" + (exception == null ? "无异常" : exception.getClass()));
        }).exceptionally(exception -> {
            System.out.println("计算执行过程中发生了异常，exception:" + exception.getClass());
            return 0;
        });

       System.out.println("执行到最后一段代码了，future result：" + future.get());
    }

> 打印执行结果：  
准备抛出异常
抛了
计算已执行完毕，result:null
计算已执行完毕，result:null
计算已执行完毕，exception:class java.util.concurrent.CompletionException
计算已执行完毕，exception:class java.util.concurrent.CompletionException
计算执行过程中发生了异常，exception:class java.util.concurrent.CompletionException
计算执行过程中发生了异常，exception:class java.util.concurrent.CompletionException
Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.RuntimeException: 主动抛出异常
	at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
	at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
	at me.ele.ecs.eapp.service.impl.Main.main(Main.java:69)
Caused by: java.lang.RuntimeException: 主动抛出异常
	at me.ele.ecs.eapp.service.impl.Main.throwException(Main.java:37)
	at me.ele.ecs.eapp.service.impl.Main.lambda$main$0(Main.java:44)

exceptionally实例2：

    //这里的打印结果是和上面类似的，可是为什么这次要获取新的CompletableFuture对象呢？看下面的exceptionally实例3后，再回来对比吧
    public static void main(String[] args) throws Exception{

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> throwException());

        CompletableFuture<Integer> future2 = future.whenCompleteAsync((result, exception) -> {
            System.out.println("计算已执行完毕，result:" + result);
            System.out.println("计算已执行完毕，exception:" + (exception == null ? "无异常" : exception.getClass()));
        });

        CompletableFuture<Integer> future3 = future2.exceptionally(exception -> {
            System.out.println("计算执行过程中发生了异常，exception:" + exception.getClass());
            return 0;
        });

        System.out.println("执行到最后一段代码了，future result：" + future.get());
       //因为上面的执行过程中，已经抛出了异常了，那么下面的这两段代码是无法执行到的，
        System.out.println("执行到最后一段代码了，future2 result：" + future2.get());
        System.out.println("执行到最后一段代码了，future3 result：" + future3.get());
    }

> 打印执行结果：  
准备抛出异常
抛了
计算已执行完毕，result:null
计算已执行完毕，exception:class java.util.concurrent.CompletionException
计算执行过程中发生了异常，exception:class java.util.concurrent.CompletionException
Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.RuntimeException: 主动抛出异常
	at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
	at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
	at me.ele.ecs.eapp.service.impl.Main.main(Main.java:69)
Caused by: java.lang.RuntimeException: 主动抛出异常
	at me.ele.ecs.eapp.service.impl.Main.throwException(Main.java:37)
	at me.ele.ecs.eapp.service.impl.Main.lambda$main$0(Main.java:44)

exceptionally实例3：

    //
    public static void main(String[] args) throws Exception{

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> throwException());

        CompletableFuture<Integer> future2 = future.whenCompleteAsync((result, exception) -> {
            System.out.println("计算已执行完毕，result:" + result);
            System.out.println("计算已执行完毕，exception:" + (exception == null ? "无异常" : exception.getClass()));
        });

        CompletableFuture<Integer> future3 = future2.exceptionally(exception -> {
            System.out.println("计算执行过程中发生了异常，exception:" + exception.getClass());
            //这里的返回值实际其是没有用处的。因为如果抛出了异常，future的get方法是执行不到的；而如果没有抛出异常的话，还是会返回原始的CompletableFuture的值的
            //所以这个exceptionally就是仅仅用来处理异常的。
            return 0;
        });

        //System.out.println("执行到最后一段代码了，future result：" + future.get());
        //System.out.println("执行到最后一段代码了，future2 result：" + future2.get());
        //和上面实例2唯一的区别就是注释掉了上面两段代码，但是执行结果却不一样了，而且整个main方法都没有抛出来异常，原因就在于future和future2是异步执行的，所以是在别的线程抛了异常，而main方法是不会抛出来的。而且在获取future3的结果时，可以发现，返回了future3对象自定义的返回值
        System.out.println("执行到最后一段代码了，future3 result：" + future3.get());
    }

> 打印执行结果：  
准备抛出异常
抛了
计算已执行完毕，result:null
计算已执行完毕，exception:class java.util.concurrent.CompletionException
计算执行过程中发生了异常，exception:class java.util.concurrent.CompletionException
执行到最后一段代码了，future3 result：0

exceptionally实例4：

    public static void main(String[] args) throws Exception{

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(Main::getMoreData);

        CompletableFuture<Integer> future2 = future.whenCompleteAsync((result, exception) -> {
            System.out.println("计算已执行完毕，result:" + result);
            System.out.println("计算已执行完毕，exception:" + (exception == null ? "无异常" : exception.getClass()));
        });

        CompletableFuture<Integer> future3 = future2.exceptionally(exception -> {
            System.out.println("计算执行过程中发生了异常，exception:" + exception.getClass());
            return 0;
        });

        System.out.println("执行到最后一段代码了，future result：" + future.get());
        System.out.println("执行到最后一段代码了，future2 result：" + future2.get());
        //原始的计算逻辑不变，exceptionally返回的新的CompletableFuture对象的结果和原始计算逻辑返回的结果一致。
        System.out.println("执行到最后一段代码了，future3 result：" + future3.get());
    }

> 打印执行结果：  
begin to start compute
end to compute, passed:1551239497158
getMoreData: 679
执行到最后一段代码了，future result：679
计算已执行完毕，result:679
计算已执行完毕，exception:无异常
执行到最后一段代码了，future2 result：679
执行到最后一段代码了，future3 result：679

2.handle* 方法

和 whenComplete* 方法一样，都是在任务执行完后，执行该方法的逻辑，但是和 whenComplete* 不同的是：
该操作执行完毕后，它返回的新CompletableFuture对象的计算结果是handle*方法的返回值，并不是原始计算逻辑的返回值

//同步
public <U> CompletableFuture<U> 	handle(BiFunction<? super T,Throwable,? extends U> fn)
//异步，使用原始CompletableFuture的线程
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)

实例：

    public static void main(String[] args) throws Exception{

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(Main::getMoreData);

        CompletableFuture<Integer> future2 = future.handleAsync((result, exception) -> {
            System.out.println("计算已执行完毕，result:" + result);
            System.out.println("计算已执行完毕，exception:" + (exception == null ? "无异常" : exception.getClass()));
            return result + 1;
        });

        System.out.println("执行到最后一段代码了，future result：" + future.get());
        System.out.println("执行到最后一段代码了，future2 result：" + future2.get());
    }

> 打印执行结果：  
begin to start compute
end to compute, passed:1551243326193
getMoreData: 395
执行到最后一段代码了，future result：395
计算已执行完毕，result:395
计算已执行完毕，exception:无异常
执行到最后一段代码了，future2 result：396

3.thenApply* 方法：连接

thenApply* 可以连接多个CompletableFuture对象，相当于将一个一个的CompletableFuture串联起来了，第一个CompletableFuture对象的结果会传递到下一个对象中，并且下一个CompletableFuture对象的结算结果会作为上一个对象的CompletableFuture结果，依次类推，也就是说会改变原始CompletableFuture对象的结果。
注：它和 handle 方法有点类似，都会拿到上一个CompletableFuture对象的结果进行计算，但是区别就是thenApply 会改变原始对象的计算结果，而 handle* 并不会**。

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)

public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
        return 100;
        });
       //由于这里同时连接了多个thenApplyAsync，第一个是异步的，第二个是同步的，并且都没有处理异常，所以异常会直接在执行计算的线程上抛出来。
       CompletableFuture<String> f =  future.thenApplyAsync(i -> i * 10).thenApply(i -> i.toString());
       System.out.println(f.get()); //"1000"
}

4. thenAccept* 方法：纯消费一个CompletableFuture对象的结果

thenAccept* 返回的新的CompletableFuture对象不返回结果，如果使用get方法，会返回一个null。

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)

public static void main(String[] args) throws ExecutionException, InterruptedException {
         CompletableFuture<Integer> future = CompletableFuture.supplyAsync(Main::getMoreData);

        CompletableFuture<Void> future2 = future.thenAccept(result -> {
            System.out.println("执行到thenAccept了, result：" + result);
        });

        System.out.println("执行到最后一段代码了，future result：" + future.get());
        System.out.println("执行到最后一段代码了，future2 result: " + future2.get());
}
> 打印执行结果：
begin to start compute
end to compute, passed:1551341977684
getMoreData: 171
执行到thenAccept了, result：171
执行到最后一段代码了，future result：171
执行到最后一段代码了，future2 result: null

5. thenAcceptBoth* 方法：在两个CompletableFuture对象的执行完后执行。

它和 thenAccept 一样，都是纯消费，但是thenAccept*只能消费一个CompletableFuture对象，而thenAcceptBoth* 能在两个不同的CompletableFuture对象执行完成后，消费他们两个的计算结果。
而且他仅仅在原始的两个CompletableFuture对象都计算成功之后，才开始执行。

public <U> CompletableFuture<Void> 	thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)
public <U> CompletableFuture<Void> 	thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)
public <U> CompletableFuture<Void> 	thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action, Executor executor)

//runAfterBoth和上面三个的区别就是它不消费原始的CompletableFuture结果
public     CompletableFuture<Void> 	runAfterBoth(CompletionStage<?> other,  Runnable action)

public static void main(String[] args) throws ExecutionException, InterruptedException {
         CompletableFuture<Integer> future = CompletableFuture.supplyAsync(Main::getMoreData);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(Main::getMoreData);

        future.thenAcceptBothAsync(future2, (x, y) -> {
            System.out.println("future1 和 future都执行完成了，结果分别是：" + x + "," + y);
        });

        System.out.println("执行到最后一段代码了，future result：" + future.get());
        System.out.println("执行到最后一段代码了，future2 result: " + future2.get());
}
> 打印执行结果：
begin to start compute
begin to start compute
end to compute, passed:1551342475808
getMoreData: 920
执行到最后一段代码了，future result：920
end to compute, passed:1551342475811
getMoreData: 747
执行到最后一段代码了，future2 result: 747
future1 和 future都执行完成了，结果分别是：920,747

6. thenRun* 方法：不消费CompletableFuture对象的结果，执行一个新任务。

在原始CompletableFuture执行任务结束后，而且执行指定的任务，不消费，也不产生结果。

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

public static void main(String[] args) throws ExecutionException, InterruptedException {
         CompletableFuture<Integer> future = CompletableFuture.supplyAsync(Main::getMoreData);

        CompletableFuture<Void> future2 = future.thenRunAsync(() -> {
            System.out.println("future执行完成了");
        });

        System.out.println("执行到最后一段代码了，future result：" + future.get());
        System.out.println("执行到最后一段代码了，future2 result：" + future2.get());
}
> 打印执行结果：
begin to start compute
end to compute, passed:1551344347162
getMoreData: 688
执行到最后一段代码了，future result：688
future执行完成了
执行到最后一段代码了，future2 result：null

7.acceptEither* ：当任意一个CompletableFuture计算完成的时候就会执行，它没有返回值。

runAfterBoth是当两个CompletableFuture都计算完成后才执行。

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

8.applyToEither*：当任意一个CompletableFuture计算完成的时候就会执行，它有返回值。

runAfterBoth是当两个CompletableFuture都计算完成后才执行。而 acceptEither* 没有返回值。

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)

辅助方法 ：allOf 和 anyOf

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

更进一步

如果你用过Guava的Future类，你就会知道它的Futures辅助类提供了很多便利方法，用来处理多个Future，而不像Java的CompletableFuture，只提供了allOf、anyOf两个方法。 比如有这样一个需求，将多个CompletableFuture组合成一个CompletableFuture，这个组合后的CompletableFuture的计算结果是个List,它包含前面所有的CompletableFuture的计算结果，guava的Futures.allAsList可以实现这样的功能，但是对于java CompletableFuture，我们需要一些辅助方法：

   public static <T> CompletableFuture<List<T>> sequence(List<CompletableFuture<T>> futures) {
       CompletableFuture<Void> allDoneFuture = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]));
       return allDoneFuture.thenApply(v -> futures.stream().map(CompletableFuture::join).collect(Collectors.<T>toList()));
   }
public static <T> CompletableFuture<Stream<T>> sequence(Stream<CompletableFuture<T>> futures) {
       List<CompletableFuture<T>> futureList = futures.filter(f -> f != null).collect(Collectors.toList());
       return sequence(futureList);
   }

Java Future转CompletableFuture:

public static <T> CompletableFuture<T> toCompletable(Future<T> future, Executor executor) {
    return CompletableFuture.supplyAsync(() -> {
        try {
            return future.get();
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }
    }, executor);
}

本文大量参考了鸟窝的文章，本人只是将实例便于理解。
地址：https://colobu.com/2016/02/29/Java-CompletableFuture/

转载于:https://my.oschina.net/u/3244997/blog/2248986

chuopi0561
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java类库BeanUtils组件使用方法及实例详解
08-25
主要介绍了Java类库BeanUtils组件使用方法级实例详解,需要的朋友可以参考下
Java super关键字的使用方法详解
08-29
Java super关键字的使用方法详解 Java super关键字是Java语言中的一种关键字，用于访问父类的成员变量和方法。在Java子类中，super关键字可以用来调用父类的构造方法、成员变量和方法，或者访问父类中的成员变量和...
CompletableFuture使用教程
热门推荐
weixin_40719914的博客
09-26 1万+
Java 8 CompletableFuture 教程 原文链接：https://www.callicoder.com/java-8-completablefuture-tutorial/ Java 8 有大量的新特性和增强如 Lambda 表达式，Streams，CompletableFuture等。在本篇文章中我将详细解释清楚CompletableFuture以及它所有方法的使用。 什么是CompletableFuture？ 在Java中CompletableFuture用于异步编程，异步编程是编写
java：CompletableFuture使用
a232884c的博客
10-07 7873
1 前言FutureTask的get()方法会造成阻塞，而轮询isDone()又会耗费CPU，jdk1.8引入了CompletableFuture，作者是Doug Lea。CompletableFuture针对Future的一些缺点进行了优化，例如回调通知，异步任务完成或产生异常，自动调用回调方法；创建异步任务，多个任务前后可组合处理等等。2 使用2.1 CompletableFuture的4个静态方法简介CompletableFuture除了实现了Future接口，还实现了CompletionStage接
CompletableFuture详细讲解
最新发布
YYVeryGood的博客
05-29 2185
是Java提供的一个实现Future接口的类，它不仅支持传统的Future接口方法，还引入了许多新的方法来支持回调、组合、处理异常等功能。通过这些方法，开发者可以更方便地编写异步代码。默认情况下，使用作为其默认的线程池。你可以自定义执行器来控制任务的执行方式：​​。
CompletableFuture用法详解
weixin_46217160的博客
05-24 8989
JAVA支持的多线程开启方式 根据Oracle官方出具的Java文档说明，创建线程的方式只有两种：继承Thread或者实现Runnable接口。 但是这两种方法都存在一个缺陷，没有返回值，也就是说我们无法得知线程执行结果。虽然简单场景下已经满足，但是当我们需要返回值的时候怎么办呢？ Java 1.5 以后的Callable和Future接口就解决了这个问题，我们可以通过向线程池提交一个Callable来获取一个包含返回值的Future对象，从此，我们的程序逻辑就不再是同步顺序。 下面是Java8实战书籍
CompletableFuture使用详解
qq_39939541的博客
07-03 2188
CompletableFuture是Java 8中新增的一个类，它实现了CompletionStage接口和Future接口。CompletionStage接口是对Future接口的扩展，提供了更多的功能和灵活性。CompletableFuture提供了一系列的方法，用于处理异步任务的结果。它可以让任务在后台线程中执行，并且可以通过回调函数来处理任务的结果。这种异步的方式可以提高程序的性能，避免阻塞主线程。除了异步执行，CompletableFuture还提供了流式处理的能力。
Java8 CompletableFuture详解
09-04
Java 8 的 `CompletableFuture` 是对传统 `Future` 接口的重要扩展，它引入了丰富的功能，使得异步编程和事件驱动模型更加便捷。`CompletableFuture` 不仅集成了 Guava 的 `ListenableFuture` 和 `SettableFuture` ...
Java-Java8十大特性详解教程
11-08
Java8 十大特性详解教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
Java中的泛型方法详解及简单实例
08-31
本文将深入探讨Java中的泛型方法，包括其定义、调用方式以及使用场景。 1. **泛型方法的定义** 泛型方法与泛型类不同，泛型类在创建实例时需要指定类型参数，而泛型方法则是在方法被调用时确定类型。定义泛型方法...
【OPCUA】使用Java开源项目milo连接KEPServerEX6服务器并读取值
MarcherXL的博客
11-07 3846
使用Java开源项目milo连接KEPServerEX6服务器并读取值，提供项目小demo，帮助解决问题
CompletableFuture详解-初遇者-很细
码灵的博客
05-26 5614
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。代码涉及到lambda表达式用法，不熟悉的可先看下。
Java的Future机制详解
u013950690的博客
03-31 2848
B图表达的是使用Future模式之后，我们主线程在invoke之后可以立即返回，去做其他的事情，回头再来看看刚才提交的invoke有没有结果。而如果使用第二个构造函数那么最后获取线程实行结果就是参数中的result，接下来让我们看一下FutureTask的run方法。方法能准确地告诉你某个字段相对于对象的起始内存地址的字节偏移量，因为是相对偏移量，所以它其实跟某个具体对象又没什么太大关系，跟class的定义和虚拟机的内存模型的实现细节更相关。get方法有两个，一个是有超时时间设置，另一个没有超时时间设置。
CompletableFuture原理与用法
旷野历程
01-15 1365
在Java中CompletableFuture用于异步编程，异步通常意味着非阻塞，运行任务单独的线程，与主线程隔离。并且通过回调可以在主线程中得到异步任务的执行状态，是否完成和异常等信息。通过这种方式，主线程不会被阻塞，不需要一直等到子线程完成。主线程可以并行的执行其他任务。使用这种并行方式，可以极大的提高程序的性能。CompletableFuture 可以从全局的 ForkJoinPool.commonPool() 获得一个线程中执行这些任务。
java futuretask和com_Java 线程池Future和FutureTask
weixin_33421065的博客
02-25 216
Future表示一个任务的周期，并提供了相应的方法来判断是否已经完成或者取消，以及获取任务的结果和取消任务。Future接口源码：public interface Future{boolean cancel(booleanmayInterruptIfRunning);booleanisCancelled();booleanisDone();V get()throwsInterruptedExcep...
completable 用法
aixian1133的博客
04-28 634
CompletableFuture 　　前面我们使用过jdk5 提出future的用法,但是在获取结果上并不是那么友好 　　在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。 　　...
java 方法的用法、重载、及递归
Sl_4397的博客
10-18 262
Java中的方法就是一个代码片段类似与c语言中的函数，学习方法时可以结合c语言中的函数来理解。 方法的特点 能够模块化的组织代码。(当代码规模比较复杂的时候). 做到代码被重复使用, 一份代码可以在多个位置使用。 让代码更好理解更简单，使代码看起来更加简单明了。 直接调用现有方法开发, 不必重复造轮子。 方法的用法 基本语法 方法定义： public static 方法返回值 方法名称（[参数...
多线程编程细节
qq_45874107的博客
02-09 1124
多线程编程细节 Thread类 Thread类实现了Runnable接口，所以Thread对象也是可运行Runnable对象，同时Thread类也是线程类 构造器 常见方法： Runnable接口 Runnable接口只定义了一个方法public void run()，这个方法要求实现Runnable接口的类实现，Runnable对象称 为可运行对象，一个线程的运行就是执行该对象的run()方法 run()方法没有返回值void，而且不能抛出异常 Callable接口 继承Thread或实现Runnabl

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值