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