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);
    }