GUAVA-ListenableFuture实现回调

随着软件开发的不断进步，在实际的开发应用中，可能一次请求需要查询若干次数据库或者调用若干次第三方，按照传统的串行执行的话，会大大增加响应时间，无法满足业务需求，更无法满足用户迫切需要响应迅速的愿望。对此，我们需要针对网络请求或内部调用中包含的“多任务”进行异步处理，并行去执行这些“任务”，这样就就会大大减小响应时间。本文是基于guava中的ListenableFuture来实现的。

 测试代码：

package com.study1;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.LockSupport;

import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
/**
 * GUAVA  ListenableFuture
 * @author gaojy
 *
 */
public class TestListenableFuture {
    //定义一个线程池，用于处理所有任务
    final static ListeningExecutorService service 
                = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

    public static void main(String[] args){
        Long t1 = System.currentTimeMillis();
        // 任务1  
        ListenableFuture<Boolean> booleanTask = service.submit(new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                Thread.sleep(10000);
                return true;
            }
        });

        /**
         * 
         */
        Futures.addCallback(booleanTask, new FutureCallback<Boolean>() {
            @Override
            public void onSuccess(Boolean result) {
                System.err.println("BooleanTask: " + result);
            }

            @Override
            public void onFailure(Throwable t) {
            }
        });

        // 任务2
        ListenableFuture<String> stringTask = service.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(10000);
                return "Hello World";
            }
        });

        Futures.addCallback(stringTask, new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.err.println("StringTask: " + result);
            }

            @Override
            public void onFailure(Throwable t) {
            }
        });

        // 任务3
        ListenableFuture<Integer> integerTask = service.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                Thread.sleep(10000);
                return new Random().nextInt(100);
            }
        });

        Futures.addCallback(integerTask, new FutureCallback<Integer>() {
            @Override
            public void onSuccess(Integer result) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.err.println("IntegerTask: " + result);
            }

            @Override
            public void onFailure(Throwable t) {
            }
        });

        // 执行时间
        System.err.println("time: " + (System.currentTimeMillis() - t1));
        
    }
}

 

测试结果：

源码分析：

在26行中ListeningExecutorService的submit（）方法：

 public ListenableFuture submit(Runnable task, Object result)
    {
        // 初始化了ListenableFutureTask对象
        ListenableFutureTask ftask = ListenableFutureTask.create(task, result);
        //执行task，实际上调用了Callable对象的call()方法
        execute(ftask);
        return ftask;
    }

再来查看一下Futures.addCallback的方法：

 public static void addCallback(ListenableFuture future, FutureCallback callback, Executor executor)
    {
      //对回调task进行检查
        Preconditions.checkNotNull(callback);
    //创建一个新的Runnable对象，并放到一个指定的线程中，执行。
   //这个Runnable对象主要任务就是获得future的结果，并根据结果调用回调函数的相应方法
        Runnable callbackListener = new Runnable(future, callback) {

            public void run()
            {
                Object value;
                try
                {
  //获取future执行结果，内部调用future.get（），产生堵塞，而不影响main主线程的执行，当获取到value时，就调用callback的onSuccess（）方法
                    value = Uninterruptibles.getUninterruptibly(future);
                }
                catch(ExecutionException e)
                {
                    callback.onFailure(e.getCause());
                    return;
                }
                catch(RuntimeException e)
                {
                    callback.onFailure(e);
                    return;
                }
                catch(Error e)
                {
                    callback.onFailure(e);
                    return;
                }
                callback.onSuccess(value);
            }

            final ListenableFuture val$future;
            final FutureCallback val$callback;

            
            {
                future = listenablefuture;
                callback = futurecallback;
                super();
            }
        }
;
        future.addListener(callbackListener, executor);
    }