java Future && Guava Future

### java future

Runnable的任务是没有返回值，也不能抛出异常的
java.util.concurrent.Callable接口，可以返回一个对象或者抛出异常

使用jdk的这种方式提交Callble任务，如果使用Future等待返回结果，这里就是阻塞的。所以，可能某一个任务时间很长会拖累整个主任务的执行。

 public class TestFuture {
     final static ExecutorService executorService = Executors.newCachedThreadPool();

     public static void main(String[] args) {
         Future<Boolean> booleanTask = executorService.submit(new Callable<Boolean>() {
             @Override
             public Boolean call() throws Exception {

                 return true;
             }
         });

         while (true) {
             if (booleanTask.isDone() && !booleanTask.isCancelled()) {
                 try {
                     TimeUnit.SECONDS.sleep(5);
                     Boolean result = booleanTask.get();
                     System.out.println("BooleanTask : " + result);
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
                 break;
             }
         }

         if (booleanTask.isDone() && !booleanTask.isCancelled()) {
             try {

                 Boolean result = booleanTask.get();
                 System.out.println("BooleanTask : " + result);
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
         System.out.println(booleanTask.isCancelled());
         System.out.println("BooleanTask is over");

         Future<String> stringTask = executorService.submit(new Callable<String>() {
             @Override
             public String call() throws Exception {

                 return "Hello world";
             }
         });

         /**
         cancel只能取消还没有提交或者执行的线程任务，所以这里无法确定是否成功取消了submit的callab le任务，stringTask.isCancelled()的值也就是不确定的
         **/

         stringTask.cancel(true);

         while (true) {
             if (stringTask.isDone() && !stringTask.isCancelled()) {
                 try {

                     TimeUnit.SECONDS.sleep(5);
                     String result = stringTask.get();
                     System.out.println("StringTask : " + result);
                 } catch (Exception e) {
                     e.printStackTrace();
                 }

                 break;
             }

         }

         System.out.println("StringTask is over");
         System.out.println(stringTask.isDone());
         System.out.println(stringTask.isCancelled());

     }
 } 

###代码片段

 List<Future<Integer>> futures = Lists.newArrayList();
         for (final AuditTask task : taskList) {
             futures.add(ThreadUtils.CUSTOM_THREAD_EXECUTOR.submit(new Callable<Integer>() {

                 @Override
                 public Integer call() throws Exception {
                     try {
                         sendToAkaOperation(task);
                         return COUNT_ONE;
                     } catch (Exception e) {
                         return COUNT_ZERO;
                     }
                 }
             }));
         }

         int count = 0;
         for (Future<Integer> future : futures) {
             try {
             //阻塞，可能由于某个任务的执行影响整个主任务
                 count = count + future.get();
             } catch (Exception e) {
                 log.error("一次推送auditPageDataWide到AKA任务异常：" + e.getMessage());
             }
         }
         log.info("一次送审任务结束，本次送审任务完成送审AKA物料数目： " + count);
     }

### guava future

ListenableFuture是可以监听的Future,如果任务完成或者失败可以自动回调函数。这样多个任务可以异步执行，并且可以实现无阻塞的获取每个任务的执行结果。

 public class TestListenableFuture {
     final static ListeningExecutorService LISTENING_EXECUTOR_SERVICE = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());

     public static void main(String[] args) {
         ListenableFuture<Boolean> booleanTask = LISTENING_EXECUTOR_SERVICE.submit(new Callable<Boolean>() {
             @Override
             public Boolean call() throws Exception {
                 TimeUnit.SECONDS.sleep(5);
                 return true;
             }
         });

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

             @Override
             public void onFailure(Throwable throwable) {

             }
         });

         ListenableFuture<String> stringTask = LISTENING_EXECUTOR_SERVICE.submit(new Callable<String>() {
             @Override
             public String call() throws Exception {
                 return "Hello world";
             }
         });

         Futures.addCallback(stringTask, new FutureCallback<String>() {
             @Override
             public void onSuccess(String aBoolean) {
                 System.out.println(Thread.currentThread().getName());
                 System.out.println("StringTask : " + aBoolean);
             }

             @Override
             public void onFailure(Throwable throwable) {

             }
         });

     }
 }

输出结果：
main
StringTask : Hello world
BooleanTask : true