详解Java CompletableFuture使用方法以及与FutureTask的区别

目录

• futureTask 创建异步任务
• 创建任务
• 1. .supplyAsync
• 2. .runAsync
• 异步回调
• 1. .thenApply
• 2. .thenAccept
• 3. .exceptionally
• 4. .whenComplete
• 组合处理

总的来说简洁了FutureTask与线程池的配合使用

没啥太大区别吧我觉得, 使用方法不一样, 多了一些方法 ???

futureTask 创建异步任务

        FutureTask<String> stringFutureTask = new FutureTask<>(() -> {
            return "aa";
        });
        executorService.execute(stringFutureTask);
        System.out.println(stringFutureTask.get());
 
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            return "aa";
        }, executorService); // 不用手动提交了
        System.out.println(future1.get());

还有很多异步回调, 组合处理

创建任务

1. .supplyAsync

创建一个带返回值的任务

2. .runAsync

创建一个不带返回值的任务

        ExecutorService executorService = Executors.newFixedThreadPool(1);
 
        // 带返回值
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("future　" + new Date());
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "aaa";
        }, executorService); // 推荐使用

以上两个方法都有两个构造方法, 默认不指定自定义线程池, 他会指定默认的提交任务的方法

    // 查看cpu的核数是否大于1核
    private static final boolean useCommonPool =
        (ForkJoinPool.getCommonPoolParallelism() > 1);
 
    // 如果大于1核 则调用execute方法, 每次创建一个线程
    private static final Executor asyncPool = useCommonPool ?
        ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();
 
    static final class ThreadPerTaskExecutor implements Executor {
        public void execute(Runnable r) { new Thread(r).start(); }
    }

所以推荐自定义线程池的方式

异步回调

指的是 异步任务结束后调用的任务

1. .thenApply

带返回值的异步调用函数, 有入参, 有出参

2. .thenAccept

不带返回值的异步回调函数, 有入参

 
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("future　" + new Date());
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "aaa";
        }, executorService);
 
        // future执行完之后执行的异步任务
        CompletableFuture<String> thenApply = future.thenApply((result) -> {
            System.out.println("future2　" +new Date());
            System.out.println(result);
            return "bbb" + result;
        });

3. .exceptionally

异步任务出现异常调用的回调方法

        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("future　" + new Date());
                Thread.sleep(2000);
                int a = 1 / 0;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "aaa";
        }, executorService);
 
        CompletableFuture<String> exceptionally = future.exceptionally((result) -> {
            System.out.println("future3 " + result);
            return "bbb" + result;
        });
        
        // 出现异常则返回异常, 没异常则返回future的返回值
        System.out.println(exceptionally.get());

去掉异常

4. .whenComplete

当主任务出现异常时, 会终止任务,get的时候会抛出主任务的异常, 入参值为null, 否则正常运行

        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("future　" + new Date());
                Thread.sleep(2000);
                int a = 1/0;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "aaa";
        }, executorService);
 
        CompletableFuture<String> exceptionally = future.whenComplete((result, error) -> {
            System.out.println("future3 " + result);
            System.out.println("future3 " + error);
        });
        System.out.println(exceptionally.get());

去掉异常

组合处理

....

就是将多个任务组合起来执行, 时间原因, 这里我就不介绍了, 大家另行百度吧

到此这篇关于详解Java CompletableFuture使用方法的文章就介绍到这了,更多相关Java CompletableFuture内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！