guava的ListenableFuture使用

java中并行处理带有返回值的方法，会使用ExecutorService和future异步的从Callable获取结果。

public class FutureTest {
  //多个任务异步执行，使用线程池，并行执行
  //这里任务抽象成一组数字，线程内睡相应数字的秒数，然后利用future返回结果
  //任务在for循环添加进service里，submit后就开始执行，随后get时会阻塞的拿结果，如果结果还没返回（还在睡中）就一直阻塞
  //当任务顺序为1，2，3。。。。时，在1s后会返回1，以此类推，在1s取得第一个结果时，其他任务也执行了1s，所以再过1s，第二个任务就会返回，共执行2s。以此类推。
  //这样会有一个问题，就是当任务变成6，5，4.。。时，第一个任务的获取时间会达到6s，由于future的get方法是阻塞的，所以别的任务在6s时已经执行完了，但是由于
  //第一个get方法还在阻塞，所以未能执行到get方法，不会返回结果，当第一个很慢的任务返回后，低于它处理时间的其他任务结果get方法会瞬间返回。
  //这样处理的总时间是不变的，但是由于第一个任务的很慢，导致已经有了结果的任务拿不到结果，所以要用guava的listenableFuture。
  public static void main(String[] args) throws Exception {
    long t1 = System.currentTimeMillis();
    ExecutorService service = Executors.newFixedThreadPool(12);
    //List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5, 6);
    List<Integer> list = Lists.newArrayList(6, 5, 4, 3, 2, 1);
    List<Future> futureList = Lists.newArrayListWithExpectedSize(6);
    for (Integer item : list) {
      Future future = service.submit(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
          TimeUnit.SECONDS.sleep(item);
          return item;
        }
      });
      futureList.add(future);
    }

    //TimeUnit.SECONDS.sleep(5);
    long t2 = System.currentTimeMillis();
    System.out.println(t2 - t1);

    try {

      for (Future future : futureList) {
        System.out.println(future.get());
      }
      long t3 = System.currentTimeMillis();
      System.out.println(t3 - t2);
      System.out.println(t3 - t1);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      service.shutdown();
    }
  }
}

这是java的做法，实现了异步阻塞的多线程处理方式，但是在代码注释的描述中说了，由于是阻塞的，会导致如果第一个任务返回很慢，会影响其他任务返回，比如处理多个图片，视频下载任务，遇到一个大的视频下载，阻塞住主线程，会影响其他小的图片的后续处理流程。
guava对java的future进行了封装，实现了异步非阻塞的多线程任务处理。

public class ListenableFutureTest {
  //与java原始的future处理总时间是一样的，但是是非阻塞的，可以再第一个任务很慢的情况下，先返回后面不慢的任务的结果。
  private static ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(20));

  public static void main(String[] args) {

    List<Integer> list = Lists.newArrayList(6, 5, 4, 3, 2, 1);

    for (Integer item : list) {
      ListenableFuture future = service.submit(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
          TimeUnit.SECONDS.sleep(item);
          return item;
        }
      });


      Futures.addCallback(future, new FutureCallback<Integer>() {

        @Override
        public void onSuccess(Integer result) {
          System.out.println("------");
          System.out.println(item);
          System.out.println(result);
          System.out.println("------");
        }

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

    service.shutdown();

  }
}

虽然这样处理的总时间是一样的（由于异步），但是后续的处理会提高效率，主线程的每个任务的get不是阻塞的，谁先处理完成，谁先返回结果。

---

简单的看了一下，guava是怎么做到，怎么封装的。
它是在自己的实现中，对每个任务都另起一个线程，通过isDone方法判断是否返回，并真正的调用future的get方法，这里是真正阻塞的地方，然后每个任务返回结果后，调用onSuccess返回结果。
也就是为每个任务轮询结果而创建一个线程。在新创建的线程里进行阻塞get。