CompletableFuture异步编排

最新推荐文章于 2023-11-04 20:07:44 发布
最新推荐文章于 2023-11-04 20:07:44 发布
阅读量544 收藏 3
点赞数 1
文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37543627/article/details/121762227
版权

目录

一、介绍

二、示例

1. 异步并发，阻塞/异步合并

2. 异步并发，然后消费结果

三、源码解析

1. Future源码

2.  创建CompletableFuture

        2.1. supplyAsync

        2.2. runAsync

        2.3. completedFuture

3. CompletableFuture主要方法

        3.1 thenApply/thenAccept/thenRun

        3.2 thenCombine

        3.3 thenCompose

        3.4 whenComplete

        3.5 handle

4. 总结

        1. 方法总结

        2. 测试源码

四、参考资料

一、介绍

        Future和Callable是JDK5版本，用来获取异步处理结果。通过阻塞或轮询的方式获取结果，如：get()方法阻塞主线程，直至处理完成或超时才能获取结果。阻塞与异步编程的理念相左，同时轮询又耗费CPU资源。

        CompletableFuture是JDK8版本，扩展了Future功能。提供了异步函数式编程，可以通过回调的方式获取处理结果，并且提供了不同异步间的转换和组合（异步编排）。其内部ForkJoinPool实现异步处理，可以把异步回调方式变为同步调用实现。

二、示例

1. 异步并发，阻塞/异步合并

@GetMapping("/testAsync")
@ApiOperation("测试异步调用业")
public Response<List<WcPendantTab>> testAsync(String mgdbId1, String mgdbId2, String mgdbId3){
    // 返回结果
    List<WcPendantTab> result = Lists.newArrayList();
    try {
        // 业务查询
        CompletableFuture<List<WcPendantTab>> future1 = CompletableFuture.supplyAsync(() -> {
            return asyncService.asyncQuery(mgdbId1);
        }, executor);
        CompletableFuture<List<WcPendantTab>> future2 = CompletableFuture.supplyAsync(() -> {
            return asyncService.asyncQuery(mgdbId2);
        }, executor);
        CompletableFuture<List<WcPendantTab>> future3 = CompletableFuture.supplyAsync(() -> {
            return asyncService.asyncQuery(mgdbId3);
        }, executor);

        // 阻塞主线程，合并查询
        CompletableFuture<List<WcPendantTab>> future4  = CompletableFuture
                .allOf(future1, future2, future3)
                // thenApply阻塞主线程；thenApplyAsync不阻塞主线程，异步处理结果
                .thenApply((Void) -> {
                    List<WcPendantTab> merge = Lists.newArrayList();
                    try {
                        merge.addAll(future1.get());
                        merge.addAll(future2.get());
                        merge.addAll(future3.get());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return merge;
                });
        // 获取合并结果
        result.addAll(future4.get());
    } catch (Exception e) {
        e.printStackTrace();
        return Response.error();
    }
    return Response.success(result);
}

        上述代码，查询数据并返回。所以future4使用thenApply来阻塞主线程获取future1、future2、future3的查询结果合并后返回。若是业务需求是不返回响应数据，可以使用thenApplyAsync不阻塞主线程，异步合并处理结果。

2. 异步并发，然后消费结果

@GetMapping("/testAsync2")
@ApiOperation("测试异步调用业2")
public Response<List<WcPendantTab>> testAsync2(String mgdbId1, String mgdbId2){
    // 返回结果
    List<WcPendantTab> result = Lists.newArrayList();
    try {
        // 业务查询
        CompletableFuture<List<WcPendantTab>> future1 = CompletableFuture.supplyAsync(() -> {
            return asyncService.asyncQuery(mgdbId1);
        }, executor);
        CompletableFuture<List<WcPendantTab>> future2 = CompletableFuture.supplyAsync(() -> {
            return asyncService.asyncQuery(mgdbId2);
        }, executor);

        // 业务1消费业务2的结果，thenAcceptBoth阻塞主线程；thenAcceptBothAsync，不阻塞主线程
        future1.thenAcceptBoth(future2, new BiConsumer<List<WcPendantTab>, List<WcPendantTab>>() {
            @Override
            public void accept(List<WcPendantTab> wcPendantTabs, List<WcPendantTab> wcPendantTabs2) {
                wcPendantTabs.addAll(wcPendantTabs2);
            }
        });

        // 阻塞主线程，合并查询
        result.addAll(future1.get());
    } catch (Exception e) {
        e.printStackTrace();
        return Response.error();
    }
    return Response.success(result);
}

         上述代码，查询数据并返回。所以future1使用thenAcceptBoth来阻塞主线程获取future1、future2的查询结果，且future1使用future2的数据。若是业务需求是不返回响应数据，可以使用thenAcceptBothAsync不阻塞主线程。

三、源码解析

1. Future源码

package java.util.concurrent;

/**
 * 返回异步计算的结果
 * 检查计算是否完成；等待计算完成；结算完成获取结果
 */
public interface Future<V> {

    // 取消任务的执行
    boolean cancel(boolean mayInterruptIfRunning);

    // 任务完成前，将其取消，返回true
    boolean isCancelled();

    // 任务正常完成，返回true
    boolean isDone();

    // 等待任务执行完成，获取执行结果
    V get() throws InterruptedException, ExecutionException;
    
    // 等待多久后，获取执行结果（正常完成），否则抛出异常
    V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    
}

2.  创建CompletableFuture

        2.1. supplyAsync

异步执行任务并返回处理结果，调用方通过get()或join()获取处理结果。注意：异步执行任务是非阻塞，但是获取结果get()或join()是阻塞方法。有两种方法签名，如下：

// 默认ForkJoinPool线程池执行异步任务
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)

// 指定线程池执行异步任务
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)
/**
 * supplyAsync异步执行任务，并返回处理结果
 */
@Test
public void testSupplyAsync(){
    CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
        @Override
        public String get() {
            System.out.println("future.join()");
            return "zyq";
        }
    });
    System.out.println("future.join()2");
    System.out.println(future.join());
}

// 执行结果
future.join()2
future.join()
get result: zyq

        2.2. runAsync

异步执行任务，并没有返回结果。有两种方法签名，如下：

// 默认Fork线程池执行任务，无返回结果
public static CompletableFuture<Void> runAsync(Runnable runnable)

// 指定线程池执行任务，无返回结果
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
/**
 * runAsync异步执行任务，没有处理结果
 */
@Test
public void testRunAsync(){
    CompletableFuture<Void> future = CompletableFuture.runAsync(new Runnable() {
        @Override
        public void run() {
            System.out.println("future.join()");
        }
    });
    System.out.println("future.join()2");
    System.out.println("get result: " + future.join());
}

// 执行结果
future.join()2
future.join()
get result: null

        2.3. completedFuture

根据已知结果作为入参，创建一个CompletableFuture。

/**
 * completedFuture：根据已知结果创建一个CompletableFuture
 */
@Test
public void testCompletedFuture(){
    CompletableFuture<String> future = CompletableFuture.completedFuture("zyq");
    System.out.println("future.join()2");
    System.out.println("get result: " + future.join());
}

// 执行结果
future.join()2
get result: zyq

3. CompletableFuture主要方法

同Future相比，CompletableFuture最大的不同是支持流式（Stream）的计算处理，多个任务之间，可以前后相连，从而形成一个计算流。比如：任务1产生的结果，可以直接作为任务2的入参，参与任务2的计算，以此类推。

        3.1 thenApply/thenAccept/thenRun

a. thenApply/thenAccept/thenRun阻塞，区别：提交的任务类型不同
b. thenApplyAsync/thenAcceptAsync/thenRunAsync非阻塞
c. thenApply：Function签名（有入参和返回值），其中入参为前置任务的结果
   thenAccept：Consumer签名（有入参但是没有返回值），其中入参为前置任务的结果
   thenRun：Runnable签名（没有入参也没有返回值）

/**
 * thenApply/thenAccept/thenRun阻塞，区别：提交的任务类型不同
 * 1. thenApplyAsync/thenAcceptAsync/thenRunAsync非阻塞
 * 2. thenApply：Function签名（有入参和返回值），其中入参为前置任务的结果
 *    thenAccept：Consumer签名（有入参但是没有返回值），其中入参为前置任务的结果
 *    thenRun：Runnable签名（没有入参也没有返回值）
 */
@Test
public void testThenApplyAsync(){
    CompletableFuture<Integer> future1 = CompletableFuture.completedFuture(520);

    // future1结果作为future2的入参，Function<入参, 出参>
    CompletableFuture<String> future2 = future1.thenApplyAsync(new Function<Integer, String>() {
        @Override
        public String apply(Integer param) {
            System.out.println("future2.thenApplyAsync(): " + param);
            return param + " zyq";
        }
    });

    System.out.println("testThenApplyAsync()");
    System.out.println("get result: " + future2.join());
}

// 执行结果
testThenApplyAsync()
future2.thenApplyAsync(): 520
get result: 520 zyq

        3.2 thenCombine

thenCombine最大的不同是连接任务可以是一个独立的CompletableFuture，即：允许两个并行任务执行，最后当两个任务均完成时，再将其结果同时传递给下游任务处理。

/**
 * 允许两个并行任务执行，最后当两个任务均完成时，再将其结果同时传递给下游任务处理
 */
@Test
public void testThenCombineAsync(){
    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
        @Override
        public Integer get() {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("into future1");
            return 520;
        }
    });

    CompletableFuture<String> future2 = CompletableFuture.supplyAsync(new Supplier<String>() {
        @Override
        public String get() {
            System.out.println("into future2");
            return "zyq";
        }
    });

    // future3入参是future1、future2的处理结果
    CompletableFuture<String> future3 = future1.thenCombineAsync(future2, new BiFunction<Integer, String, String>() {
        @Override
        public String apply(Integer f1, String f2) {
            System.out.println("into future3");
            return f1 + " " + f2;
        }
    });

    System.out.println("testThenCombineAsync()");
    System.out.println("get result: " + future3.join());
}

// 执行结果
into future2
testThenCombineAsync()
into future1
into future3
get result: 520 zyq

        3.3 thenCompose

thenCombine主要用于没有前后依赖关系的任务进行连接。那么，如果两个任务之间有前后依赖关系，但是连接任务又是独立的CompletableFuture，则实现内部嵌套。

/**
 * CompletableFuture内部嵌入CompletableFuture
 */
@Test
public void testThenComposeAsync(){
    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
        @Override
        public Integer get() {
            System.out.println("into future1");
            return 520;
        }
    });

    CompletableFuture<String> future2 = future1.thenComposeAsync(new Function<Integer, CompletableFuture<String>>() {
        @Override
        public CompletableFuture<String> apply(Integer f1) {
            System.out.println("into future2");
            // 内部嵌入CompletableFuture
            return CompletableFuture.supplyAsync(new Supplier<String>() {
                @Override
                public String get() {
                    System.out.println("into future2 into CompletableFuture");
                    return f1 + " " + "zyq";
                }
            });
        }
    });

    System.out.println("testThenComposeAsync()");
    System.out.println("get result: " + future2.join());
}

// 执行结果
testThenComposeAsync()
into future1
into future2
into future2 into CompletableFuture
get result: 520 zyq

        3.4 whenComplete

前置任务完成时的回调通知逻辑，当前任务没有返回值，返回前置任务的结果。注意：解决Future任务完成时，无法主动发起通知的问题。

/**
 * 前置任务完成时的回调通知逻辑。
 * 注意：解决Future任务完成时，无法主动发起通知的问题
 */
@Test
public void testWhenCompleteAsync(){
    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
        @Override
        public Integer get() {
            System.out.println("into future1");
            return 520;
        }
    });

    // 返回是future1结果
    // 前置任务完成时的回调通知逻辑
    CompletableFuture<Integer> future2 = future1.whenCompleteAsync(new BiConsumer<Integer, Throwable>() {
        @Override
        public void accept(Integer f1, Throwable throwable) {
            System.out.println("into future2");
            // future1抛出异常
            if (Objects.nonNull(throwable)){
                System.out.println("into future2 is future1 failed");
            }
            // future1正常结果
            else {
                System.out.println("into future2 is future1 " + f1);
            }
        }
    });

    System.out.println("testWhenCompleteAsync()");
    System.out.println("get result: " + future2.join());
}

// 执行结果
into future1
testWhenCompleteAsync()
into future2
into future2 is future1 520
get result: 520

        3.5 handle

与whenComplete类似，但是有返回值，而且返回值会影响最终获取的计算结果。

/**
 * 与whenComplete类似，但是有返回值
 */
@Test
public void testHandleAsync(){
    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
        @Override
        public Integer get() {
            System.out.println("into future1");
            Long.parseLong("wer");
            return 520;
        }
    });

    // 前置任务完成时的回调通知逻辑，且有返回值
    CompletableFuture<String> future2 = future1.handleAsync(new BiFunction<Integer, Throwable, String>() {
        @Override
        public String apply(Integer f1, Throwable throwable) {
            System.out.println("into future2");
            // future1抛出异常
            if (Objects.nonNull(throwable)){
                System.out.println("into future2 is future1 failed");
                return f1 + " " + "failed";
            }
            // future1正常结果
            else {
                System.out.println("into future2 is future1 " + f1);
                return f1 + " " + "zyq";
            }
        }
    });

    System.out.println("testHandleAsync()");
    System.out.println("get result: " + future2.join());
}

// 执行结果
into future1
testHandleAsync()
into future2
into future2 is future1 failed
get result: null failed

4. 总结

        1. 方法总结

类型方法说明
创建对象supplyAsync静态方法；有返回结果
runAsync静态方法；无返回结果
completedFuture静态方法；已知入参并返回
主要方法

thenApply

/thenApplyAsync

1. 阻塞/非阻塞；

2. Function签名（有入参，有返回值）

thenAccept

/thenAcceptAsync

1. 阻塞/非阻塞；

2. Consumer签名（有入参，没有返回值）

thenRun

/thenRunAsync

1. 阻塞/非阻塞；

2. Runnable签名（没有入参，没有返回值）

thenCombine

/thenCombineAsync

1. 阻塞/非阻塞；

2. 连接任务是独立的CompletableFuture，即：允许两个并行任务执行，再将其结果同时传递给下游任务处理

thenCompose

/thenComposeAsync

1. 阻塞/非阻塞；

2. 没有前后依赖关系的任务进行连接，实现内部嵌套

whenComplete

/whenCompleteAsync

1. 阻塞/非阻塞；

2. 前置任务完成时的回调通知逻辑；

3. 当前任务没有返回值，前置任务的结果作为返回值

handle

/handleAsync

1. 阻塞/非阻塞；

2. 前置任务完成时的回调通知逻辑；

3. 当前任务有返回值，影响最终结果

        2. 测试源码

package com.cmmon.instance;

import org.junit.jupiter.api.Test;

import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @description 测试CompletableFuture
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/7 14:32
 **/
public class CompletableFutureTest {

    /**
     * supplyAsync异步执行任务，并返回处理结果
     */
    @Test
    public void testSupplyAsync(){
        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("future.join()");
                return "zyq";
            }
        });
        System.out.println("future.join()2");
        System.out.println("get result: " + future.join());
    }

    /**
     * runAsync异步执行任务，没有处理结果
     */
    @Test
    public void testRunAsync(){
        CompletableFuture<Void> future = CompletableFuture.runAsync(new Runnable() {
            @Override
            public void run() {
                System.out.println("future.join()");
            }
        });
        System.out.println("future.join()2");
        System.out.println("get result: " + future.join());
    }

    /**
     * completedFuture：根据已知结果创建一个CompletableFuture
     */
    @Test
    public void testCompletedFuture(){
        CompletableFuture<String> future = CompletableFuture.completedFuture("zyq");
        System.out.println("future.join()2");
        System.out.println("get result: " + future.join());
    }

    /**
     * thenApply/thenAccept/thenRun阻塞，区别：提交的任务类型不同
     * 1. thenApplyAsync/thenAcceptAsync/thenRunAsync非阻塞
     * 2. thenApply：Function签名（有入参和返回值），其中入参为前置任务的结果
     *    thenAccept：Consumer签名（有入参但是没有返回值），其中入参为前置任务的结果
     *    thenRun：Runnable签名（没有入参也没有返回值）
     */
    @Test
    public void testThenApplyAsync(){
        CompletableFuture<Integer> future1 = CompletableFuture.completedFuture(520);

        // future1结果作为future2的入参，Function<入参, 出参>
        CompletableFuture<String> future2 = future1.thenApplyAsync(new Function<Integer, String>() {
            @Override
            public String apply(Integer param) {
                System.out.println("future2.thenApplyAsync(): " + param);
                return param + " zyq";
            }
        });

        System.out.println("testThenApplyAsync()");
        System.out.println("get result: " + future2.join());
    }

    /**
     * 允许两个并行任务执行，最后当两个任务均完成时，再将其结果同时传递给下游任务处理
     */
    @Test
    public void testThenCombineAsync(){
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("into future1");
                return 520;
            }
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("into future2");
                return "zyq";
            }
        });

        // future3入参是future1、future2的处理结果
        CompletableFuture<String> future3 = future1.thenCombineAsync(future2, new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer f1, String f2) {
                System.out.println("into future3");
                return f1 + " " + f2;
            }
        });

        System.out.println("testThenCombineAsync()");
        System.out.println("get result: " + future3.join());
    }

    /**
     * CompletableFuture内部嵌入CompletableFuture
     */
    @Test
    public void testThenComposeAsync(){
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                System.out.println("into future1");
                return 520;
            }
        });

        CompletableFuture<String> future2 = future1.thenComposeAsync(new Function<Integer, CompletableFuture<String>>() {
            @Override
            public CompletableFuture<String> apply(Integer f1) {
                System.out.println("into future2");
                // 内部嵌入CompletableFuture
                return CompletableFuture.supplyAsync(new Supplier<String>() {
                    @Override
                    public String get() {
                        System.out.println("into future2 into CompletableFuture");
                        return f1 + " " + "zyq";
                    }
                });
            }
        });

        System.out.println("testThenComposeAsync()");
        System.out.println("get result: " + future2.join());
    }

    /**
     * 前置任务完成时的回调通知逻辑。
     * 注意：解决Future任务完成时，无法主动发起通知的问题
     */
    @Test
    public void testWhenCompleteAsync(){
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                System.out.println("into future1");
                return 520;
            }
        });

        // 返回是future1结果
        // 前置任务完成时的回调通知逻辑
        CompletableFuture<Integer> future2 = future1.whenCompleteAsync(new BiConsumer<Integer, Throwable>() {
            @Override
            public void accept(Integer f1, Throwable throwable) {
                System.out.println("into future2");
                // future1抛出异常
                if (Objects.nonNull(throwable)){
                    System.out.println("into future2 is future1 failed");
                }
                // future1正常结果
                else {
                    System.out.println("into future2 is future1 " + f1);
                }
            }
        });

        System.out.println("testWhenCompleteAsync()");
        System.out.println("get result: " + future2.join());
    }

    /**
     * 与whenComplete类似，但是有返回值
     */
    @Test
    public void testHandleAsync(){
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                System.out.println("into future1");
                Long.parseLong("wer");
                return 520;
            }
        });

        // 前置任务完成时的回调通知逻辑，且有返回值
        CompletableFuture<String> future2 = future1.handleAsync(new BiFunction<Integer, Throwable, String>() {
            @Override
            public String apply(Integer f1, Throwable throwable) {
                System.out.println("into future2");
                // future1抛出异常
                if (Objects.nonNull(throwable)){
                    System.out.println("into future2 is future1 failed");
                    return f1 + " " + "failed";
                }
                // future1正常结果
                else {
                    System.out.println("into future2 is future1 " + f1);
                    return f1 + " " + "zyq";
                }
            }
        });

        System.out.println("testHandleAsync()");
        System.out.println("get result: " + future2.join());
    }

}

四、参考资料

CompletableFuture 详解（一）：基本概念及用法_tongtest的博客-CSDN博客_completablefuture 详解

CompletableFuture详解 - 风好大 - 博客园 

Java CompletableFuture 详解 - 毛会懂 - 博客园

Java里面CompletableFuture详解_自我更新-CSDN博客_completablefuture 详解

爱我所爱0505
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
并发编程之CompletableFuture异步编排的详细介绍和基本使用（全网最细最全）
m0_56466015的博客
03-20 3041
CompletableFutyre异步编排最详细介绍和所有用法的举例说明（附源码），全网最全最细
实现异步编程，这个工具类你得掌握！
月伴飞鱼
04-18 380
我们知道多线程能并发的处理多个任务，有效地提高复杂应用程序的性能，在实际开发中扮演着十分重要的角色 但是使用多线程也带来了很多风险，并且由线程引起的问题往往在测试中难以发现，到了线上就会造成重大的故障和损失 下面我会结合几个实际案例，帮助大家在工作做规避这些问题 多线程问题 首先介绍下使用的多线程会有哪些问题 使用多线程的问题很大程度上源于多个线程对同一变量的操作权，以及不同线程之间执行顺序的不确定性 《Java并发编程实战》这本书中提到了三种多线程的问题：安全性问题、活跃性问题和性能问题 安全性问题 例如
CompletableFuture实现异步编排
m0_73311735的博客
01-30 202
为什么需要异步执行？①获取商品基本信息 ②获取商品图片信息 ③获取商品促销活动信息 ④获取商品各种类的基本信息等操作，如果使用串行方式去执行这些操作，假设每个操作执行1s，那么用户看到完整的商品详情就需要4s的时间，如果使用并行方式执行这些操作，可能只需要1s就可以完成。所以这就是异步执行的好处。JDK5的Future接口Future接口用于代表异步计算的结果，通过Future接口提供的方法可以查看异步计算是否执行完成，或者等待执行结果并获取执行结果，同时还可以取消执行。列举Futureget()
CompletableFuture异步任务编排
南顾春衫
03-14 713
使用jdk8中的java.util.concurrent.CompletableFuture非常方便进行异步任务编排 1.supplyAsync 开启异步任务 /** * 1.小白点菜 * 2.厨师做菜 * 3.小白吃饭 */ public static void test1() { SmallTools.printTimeAndThread("小白进入餐厅"); SmallTools.printTimeAndThread("小白点了 番茄炒蛋+一碗米饭"); //启动一个线
CompletableFuture 异步处理
07-16
总结，CompletableFuture是Java中处理异步编程的强大工具，它通过提供丰富的API和灵活的任务编排方式，简化了异步编程的复杂性，提升了代码的可读性和可维护性。开发者可以根据具体需求选择合适的方法，创建和组合...
Java并发 CompletableFuture异步编程的实现
08-25
Java并发 CompletableFuture异步编程的实现 在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而...
异步编排.java
06-30
异步编排.java
【Java分享客栈】一文搞定京东零售开源的AsyncTool，彻底解决异步编排问题。.doc
07-12
在上一篇讲CompletableFuture的文章中，我们了解了CompletableFuture提供的串行、并行等常用异步编排的方案。但是，在细节上还是有许多不足，比如回调方面，编排复杂顺序方面。因此，我们需要一种更加强大且灵活的...
java并发编程 线程池 异步编排
08-04
java并发编程相关总结
Java多线程--CompletableFuture异步编排
sunao1106的博客
07-28 905
举一个形象的例子： 在一个方法中实现了A、B、C三个功能，假设每个功能的执行所需要的时间分别为(5s，10s，15s)，在没有异步编排之前，进入方法依次执行 A功能—>B功能—>C功能，执行方法完毕，用时30s。当我们在方法中引入异步编排，给A、B、C每个功能都分配一个不同的线程执行，这样的情况下，最快15s这个方法就可以执行完毕，这就是所谓的异步。.........
异步任务编排利器CompletableFuture实战
最新发布
MarcoLin
11-04 160
CompletableFuture是Java8中并发包提供的异步编程实现类，它是Future接口的扩展接口，它拥有比Future更强大的能力，本篇文章将会通过例子实战演示CompletableFuture的使用方法
简述CompletableFuture异步任务编排
m0_73311735的博客
11-21 706
在之前的项目开发中，都没怎么使用过CompletableFuture的功能，只听说过和异步编程有关。为了能够在将来有需要的时候用得上，这两天花了点时间学习了一下，并简单地总结一下如何使用CompletableFuture完成异步任务编排。​@Override// 设置为守护线程，main线程结束就跟着一起结束，否则main函数结束jvm还在return t;}复制代码。
CompletableFuture的运用
haishiyizhenfeng的博客
10-22 366
1异步处理在工作中时常用，特此总结一些：目前用的多点的就是CompletableFuture其中它提供了四个方法 public static CompletableFuture<Void> runAsync(Runnable runnable) public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) public static <U> Completa..
异步编程探究JDK中的CompletableFuture(满足不同场景需求)
天涯芳草
04-14 252
CompletableFuture是一个通过编程方式显示地设置计算结果和状态以便让任务接收的Future，并且其可以作为一个CompletableStage(计算阶段),当它的计算完成时可以触发一个函数或者行为;当多个线程企图调用一个CompletableFuture的complete,cancel方发时只会有一个线程会成功。 ...
【CompletableFuture】CompletableFuture中join()和get()方法的区别
热门推荐
Zero .
12-11 3万+
【CompletableFuture】CompletableFuture中join()和get()方法的区别 一.相同点： 　　join()和get()方法都是用来获取CompletableFuture异步之后的返回值 二.区别： 　　1.join()方法抛出的是uncheck异常（即未经检查的异常),不会强制开发者抛出， 　　会将异常包装成CompletionException异常 /CancellationException异常，但是本质原因还是代码内存在的真正的异常， 　　文档说明：.
CompletableFuture功能介绍与原理分析
尘间絮的专栏
08-10 3632
CompletableFuture功能介绍与原理简析前言CompletableFuture功能介绍1.创建CompletableFuture2.CompletableFuture结果的获取3.CompletableFuture的执行状态控制4.CompletionStage接口方法的实现1）是否异步执行2）输入参数与输出结果3）依赖的CompletionStage个数4）是否可接收异常结果并处理CompletableFuture实现原理分析概念介绍1.UnSafe的应用2.Treiber stack3.Fo
completablefuture异步编排
03-16
CompletableFuture异步编排是一种Java编程语言中的异步编程模型，它可以让开发者更加方便地进行异步编程。CompletableFuture可以用来表示一个异步操作的结果，同时还可以将多个异步操作组合起来，形成一个异步操作链。在异步编排中，我们可以使用CompletableFuture来实现异步操作的串行执行、并行执行、异常处理、超时控制等功能，从而提高程序的性能和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值