JUC并发编程学习（十五）-异步回调之CompletableFuture

Future

Future接口是Java多线程Future模式的实现，在java.util.concurrent包中，可以用来进行异步计算。

Future模式是多线程中一种常用的模式。可以理解为：我有一个任务，把它交给Future去完成。在这期间我可以去做自己想干的事情，过段时间后，我可以直接去Future那提取结果。

Future的接口主要有五个方法。

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future接口的方法介绍如下：

• boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束
• boolean isCancelled () 任务是否已经取消，任务正常完成前将其取消，则返回 true
• boolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消，都将返回true
• V get () throws InterruptedException, ExecutionException 等待任务执行结束，然后获得V类型的结果。InterruptedException 线程被中断异常， ExecutionException任务执行异常，如果任务被取消，还会抛出CancellationException
• V get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样，多了设置超时时间。参数timeout指定超时时间，uint指定时间的单位，在枚举类TimeUnit中有相关的定义。如果计算超时，将抛出TimeoutException

一般情况下，我们会结合Callable和Future一起使用，通过ExecutorService的submit方法执行Callable，并返回Future。

        ExecutorService executor = Executors.newCachedThreadPool();

        Future<String> future = executor.submit(() -> { //Lambda 是一个 callable， 提交后便立即执行，这里返回的是 FutureTask 实例
            System.out.println("running task");
            Thread.sleep(10000);
            return "return task";
        });

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }

        System.out.println("do something else");  //前面的的 Callable 在其他线程中运行着，可以做一些其他的事情

        try {
            System.out.println(future.get());  //等待 future 的执行结果，执行完毕之后打印出来
        } catch (InterruptedException e) {
        } catch (ExecutionException e) {

        } finally {
            executor.shutdown();
        }

比起future.get()，其实更推荐使用get (long timeout, TimeUnit unit) 方法，设置了超时时间可以防止程序无限制的等待future的结果。

Future模式的缺点

• Future虽然可以实现获取异步执行结果的需求，但是它没有提供通知的机制，我们无法得知Future什么时候执行完成
• 要么使用阻塞，在future.get()方法的地方等待future返回的结果，这时又变成了同步操作。要么使用isDone()轮询判断Future是否完成。单这样会耗费CPU资源（CPU空转），于是completableFuture应运而生。

CompletableFuture

从Java 8开始引入了CompletableFuture，它针对Future做了改进，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。

我们以异步调用无返回值为例，看看如何使用CompletableFuture：

package com;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @className:
 * @author: youjp
 * @create: 2020-06-21 17:19
 * @description:    异步回调，completableFuture，对将来的结果进行结果，ajax请求就是一种异步回调！
 * 1.异步回调
 * 2.成功回调
 * 3.失败回调
 * @Version: 1.0
 */
public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //无返回值的异步回调测试
        CompletableFuture<Void> completableFuture=CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"：没有返回结果的回调");
        });

        System.out.println(111);

        System.out.println(completableFuture.get());    //获取阻塞执行结果：即没有获取到执行结果前，程序一直阻塞执行

    }

}

可以查看到，因为是异步执行的，所以在为获取结果前，先执行了主线程。然后再获取结果的同时阻塞去获取执行结果。

CompletableFuture有返回结果情况测试

package com;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @className:
 * @author: youjp
 * @create: 2020-06-21 17:19
 * @description:    异步回调，completableFuture，对将来的结果进行结果，ajax请求就是一种异步回调！
 * 1.异步回调
 * 2.成功回调
 * 3.失败回调
 * @Version: 1.0
 */
public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //有返回值的supplyAsync 异步回调
        //在ajax请求中，有成功和失败的回调，成功即返回成功的数据，错误就返回错误的数据
        CompletableFuture<Integer> completableFuture=CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+":异步回调，返回integer");
            return 200;
        });

        //回调成功即 success
        System.out.println("异步调用返回结果："+completableFuture.whenComplete((x,y)->{
            System.out.println("x-即success成功返回的结果:"+x); //正常返回结果
            System.out.println("y-即error错误返回的:"+y); //错误返回结果
        }).exceptionally(e->{
            System.out.println("获取异常信息"+e.getMessage());
            return 500; //返回异常结果
        }).get());

    }

}

调用成功，则获取到返回的值

设立一个程序算法异常，查看异常回调的结果

package com;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @className:
 * @author: youjp
 * @create: 2020-06-21 17:19
 * @description:    异步回调，completableFuture，对将来的结果进行结果，ajax请求就是一种异步回调！
 * 1.异步回调
 * 2.成功回调
 * 3.失败回调
 * @Version: 1.0
 */
public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //有返回值的supplyAsync 异步回调
        //在ajax请求中，有成功和失败的回调，成功即返回成功的数据，错误就返回错误的数据
        CompletableFuture<Integer> completableFuture=CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+":异步回调，返回integer");
            int num=400/0;
            return 200;
        });

        //回调成功即 success
        System.out.println("异步调用返回结果："+completableFuture.whenComplete((x,y)->{
            System.out.println("x-即success成功返回的结果:"+x); //正常返回结果
            System.out.println("y-即error错误返回的:"+y); //错误返回结果
        }).exceptionally(e->{
            System.out.println("获取异常信息"+e.getMessage());
            return 500; //返回异常结果
        }).get());

    }

}

CompletableFuture源码解析

completableFuture源码解析