Java核心复习——CompletableFuture

最新推荐文章于 2023-10-07 22:59:32 发布

coffejoy

最新推荐文章于 2023-10-07 22:59:32 发布

阅读量151

点赞数

分类专栏： Java Java核心学习

本文链接：https://blog.csdn.net/weixin_42142408/article/details/88932926

版权

Java 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

Java核心学习

7 篇文章 0 订阅

订阅专栏

介绍

JDK1.8引入CompletableFuture类。

使用方法


public class CompletableFutureTest {

    private static ExecutorService threadPool = new ThreadPoolExecutor(40, 100,
            0L, TimeUnit.MILLISECONDS,
            new ArrayBlockingQueue<>(20));

    public String B() {
        System.out.println("执行方法B");
        sleep(5);
        return "Function B";
    }

    public String C() {
        System.out.println("执行方法C");
        sleep(20);
        return "Function C";
    }


    public void sleep(int i) {
        try {
            Thread.sleep(i * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void testCompableFuture() {
        CompletableFuture<String> future;
        try {
            //Returns a new CompletableFuture 
            // that is asynchronously completed by a task running in the given executor 
            // with the value obtained by calling the given Supplier.
            future = CompletableFuture.supplyAsync(() -> B(), threadPool);
            //若去掉线程池，有何区别future = CompletableFuture.supplyAsync(() -> B());

            sleep(9);
            System.out.println(future.toString());
            System.out.println(future.isDone());
        } catch (RejectedExecutionException e) {
            System.out.println("调用搜索列表服务线程满负荷, param:{}");
        }
    }

    public static void main(String[] args) {
        CompletableFutureTest test = new CompletableFutureTest();
        test.testCompableFuture();
    }

}

API

supplyAsync方法

JDK方法描述

/**
     * Returns a new CompletableFuture that is asynchronously completed
     * by a task running in the given executor with the value obtained
     * by calling the given Supplier.
     *
     * @param supplier a function returning the value to be used
     * to complete the returned CompletableFuture
     * @param executor the executor to use for asynchronous execution
     * @param <U> the function's return type
     * @return the new CompletableFuture
     */
    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor) {
        return asyncSupplyStage(screenExecutor(executor), supplier);
    }