从Runnable到Callable，JDK虽然帮我们封装了异步结果的获取，但并没有为我们封装异步任务两种结果（正常执行或异常）的处理。

虽然我们可以调用Future的get自行获取异步结果，并根据结果（成功或异常）做对应的处理逻辑。但比较呆的点在于Future的get方法在异步任务未完成前会阻塞调用线程。

所以我们一般不这样操作。

我们希望执行异步任务的线程，在异步任务完成后，能自动调用异步结果的处理逻辑，不需要我们另起线程等待异步任务执行完成，这便是常说的异步回调。

虽然JDK没帮我们封装，但却贴心的为我们预留了异步回调的扩展点。这个点就是FutureTask类的done方法。

    /**
     * Protected method invoked when this task transitions to state
     * {@code isDone} (whether normally or via cancellation). The
     * default implementation does nothing.  Subclasses may override
     * this method to invoke completion callbacks or perform
     * bookkeeping. Note that you can query status inside the
     * implementation of this method to determine whether this task
     * has been cancelled.
     */
    protected void done() { }

这个done方法会在异步任务执行完后调用，默认是一个空实现，我们可以在子类重写这个方法，并放上异步回调的逻辑。

根据Callable任务的执行原理和JDK为我们预留的扩展点，我们可以方便的实现异步回调。
关于Callable任务的执行原理可以参考：Java Callable任务

异步回调的实现

继承AbstractExecutorService，重写newTaskFor方法：

import java.util.List;
import java.util.concurrent.*;

public class MyExecutorService extends AbstractExecutorService {
    // 执行异步任务的线程池
    private final ExecutorService taskExecutor;
    // 回调逻辑
    private final Callback callback;
    // 执行回调逻辑的线程池
    private final ExecutorService callbackExecutor;

    public MyExecutorService(ExecutorService taskExecutor, Callback callback, ExecutorService callbackExecutor) {
        this.taskExecutor = taskExecutor;
        this.callback = callback;
        this.callbackExecutor = callbackExecutor;
    }


    @Override
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<>(callable) {
            // 继承FutureTask，并重写done方法
            @Override
            protected void done() {
                T result;
                try {
                    // 执行到这的时候，异步任务已经执行完了
                    // 这个get不会阻塞，仅用来获取异步结果
                    result = get();
                } catch (Exception e) {
                    callbackExecutor.execute(() -> {
                        // 调用失败处理逻辑
                        callback.onFailure(e);
                    });
                    return;
                }
                callbackExecutor.execute(() -> {
                    // 调用成功处理逻辑
                    callback.onSuccess(result);
                });
            }
        };
    }

    @Override
    public void shutdown() {
        taskExecutor.shutdown();
    }

    @Override
    public List<Runnable> shutdownNow() {
        return taskExecutor.shutdownNow();
    }

    @Override
    public boolean isShutdown() {
        return taskExecutor.isShutdown();
    }

    @Override
    public boolean isTerminated() {
        return taskExecutor.isTerminated();
    }

    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
        return taskExecutor.awaitTermination(timeout, unit);
    }

    @Override
    public void execute(Runnable command) {
        taskExecutor.execute(command);
    }
}

执行到done方法里的get调用时，不会阻塞，因为异步任务的结果已经设置了，可以直接get到执行结果。

定义回调接口：

public interface Callback {
    <T> void onSuccess(T t);
    void onFailure(Exception e);
}

是不是挺简单的！

使用示例

模拟异步任务成功执行：

import java.util.concurrent.*;

public class JdkCallbackMechanism {
    public static void main(String[] args) throws InterruptedException {
        // 定义回调处理逻辑
        Callback callback = new Callback() {
            @Override
            public <T> void onSuccess(T t) {
                System.out.println("任务成功执行了，结果是：" + t);
            }

            @Override
            public void onFailure(Exception e) {
                System.out.println("任务执行失败了，发生了异常：" + e);
            }
        };

        // 定义处理异步任务和回调任务的线程池
        ExecutorService taskExecutor = Executors.newFixedThreadPool(3);
        ExecutorService callbackExecutor = Executors.newSingleThreadExecutor();

        // 初始化MyExecutorService
        MyExecutorService myExecutorService = new MyExecutorService(taskExecutor, callback, callbackExecutor);
        // 定义异步任务
        Callable<Integer> callable = () -> {
            System.out.println("异步任务正在执行...");
            // 模拟耗时操作
            TimeUnit.SECONDS.sleep(15);
            return 1;
        };

        // 将异步任务提交给myExecutorService
        myExecutorService.submit(callable);
    }
}

执行结果：

image.png

模拟异步任务执行失败（用除0异常模拟）：

import java.util.concurrent.*;

public class JdkCallbackMechanism {
    public static void main(String[] args) throws InterruptedException {
        // 定义回调处理逻辑
        Callback callback = new Callback() {
            @Override
            public <T> void onSuccess(T t) {
                System.out.println("任务成功执行了，结果是：" + t);
            }

            @Override
            public void onFailure(Exception e) {
                System.out.println("任务执行失败了，发生了异常：" + e);
            }
        };

        // 定义处理异步任务和回调任务的线程池
        ExecutorService taskExecutor = Executors.newFixedThreadPool(3);
        ExecutorService callbackExecutor = Executors.newSingleThreadExecutor();

        // 初始化MyExecutorService
        MyExecutorService myExecutorService = new MyExecutorService(taskExecutor, callback, callbackExecutor);
        // 定义异步任务
        Callable<Integer> callable = () -> {
            System.out.println("异步任务正在执行...");
            // 模拟耗时操作
            TimeUnit.SECONDS.sleep(15);
            return 1/0;
        };

        // 将异步任务提交给myExecutorService
        myExecutorService.submit(callable);
    }
}

执行结果：

image.png

模拟取消异步任务：

import java.util.concurrent.*;

public class JdkCallbackMechanism {
    public static void main(String[] args) throws InterruptedException {
        // 定义回调处理逻辑
        Callback callback = new Callback() {
            @Override
            public <T> void onSuccess(T t) {
                System.out.println("任务成功执行了，结果是：" + t);
            }

            @Override
            public void onFailure(Exception e) {
                System.out.println("任务执行失败了，发生了异常：" + e);
            }
        };

        // 定义处理异步任务和回调任务的线程池
        ExecutorService taskExecutor = Executors.newFixedThreadPool(3);
        ExecutorService callbackExecutor = Executors.newSingleThreadExecutor();

        // 初始化MyExecutorService
        MyExecutorService myExecutorService = new MyExecutorService(taskExecutor, callback, callbackExecutor);
        // 定义异步任务
        Callable<Integer> callable = () -> {
            System.out.println("异步任务正在执行...");
            // 模拟耗时操作
            TimeUnit.SECONDS.sleep(15);
            return 1/0;
        };

        // 将异步任务提交给myExecutorService
        Future<Integer> future = myExecutorService.submit(callable);
        TimeUnit.SECONDS.sleep(5);
        future.cancel(true);
    }
}

执行结果：

image.png

最后：工作中，其实已经有很多已经封装好的异步回调框架，不需要我们自己造轮子，比如google的guava。但本文几乎以最精简的代码实现了一个异步回调，有助于大家理解异步回调的原理。