ListenableFuture原理

java Executor

import com.google.common.util.concurrent.*;

import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

public class ListenableFutureTest {
    public static void main(String[] args) throws InterruptedException {
        testListenFuture();
    }

    public static void testListenFuture() throws InterruptedException {
        System.out.println("主线程start");
        // pool 为ListeningDecorator
        ListeningExecutorService pool = MoreExecutors.listeningDecorator(
                Executors.newFixedThreadPool(10, new ThreadFactoryBuilder()
                        .setNameFormat("hotel-reward-service-executor-%d")
                        .build()));

        Task task1 = new Task();
        task1.args = "task1";
        Task task2 = new Task();
        task2.args = "task2";
        // submit执行ListeningExecutorService的submit，
        // 该submit在AbstractListeningExecutorService重写，
        // 重写方法中执行父类的submit，就是AbstractExecutorService中的submit
        // future为AbstractExecutorService的newTaskFor后得到，该方法在AbstractListeningExecutorService中重写
        // 调用AbstractListeningExecutorService中的newTaskFor后得到的TrustedListenableFutureTask
        ListenableFuture<String> future = pool.submit(task1);
        ListenableFuture<String> future2 = pool.submit(task2);
        // 调用TrustedFuture的addListener，
        // TrustedFuture的addListener--->调用父类的 AbstractFuture 的addListener
        future2.addListener(() -> System.out.println("addListener 不能带返回值"), pool);


        /**
         * FutureCallBack接口可以对每个任务的成功或失败单独做出响应
         */
        FutureCallback<String> futureCallback = new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println("Futures.addCallback 能带返回值：" + result);
            }
            @Override
            public void onFailure(Throwable t) {
                System.out.println("出错,业务回滚或补偿");
            }
        };

        // 为任务绑定回调接口
        // 底层依然通过 addListener 实现
        // 将任务包装为 CallbackListener，其中CallbackListener实现Runnable并且重写run方法
        Futures.addCallback(future, futureCallback, pool);
        System.out.println("主线程end");

    }
}

class Task implements Callable<String> {
    String args;
    @Override
    public String call() throws Exception {
        Thread.sleep(1000);
        System.out.println("任务：" + args);
        return "dong";
    }
}