基于Guava库的ListenableFuture类实现Java异步编程

1 Future接口的缺点

通过Future接口的get()方法可以获取类Callable的返回值，但是此方法最大缺点是阻塞的，因此在并发环境下，效率比较低。Google公司提供的开源Guava库提供了有效的处理异步Future的问题。

2 addListener（）方法

Guava包的ListenableFuture实现了Future接口， 其源码如下：

public interface ListenableFuture<V> extends Future<V> {
 	 void addListener(Runnable listener, Executor executor);
}

addListener(Runnable listener, Executor executor)方法是异步的，它注册了一个监听器，当Callable类执行结束，后会进入Runnable接口的实现类中。

public class MyCallable implements Callable<String> {
	private String name;

	public MyCallable(String name) {
		this.name = name;
	}

	@Override
	public String call() throws Exception{	
		Thread.sleep(5000);
		return name;
	}	
	
}

public class ListenableFutureApp {

	public static void main(String[] args) {
			
		 /*
		  * 方法1：采用 ListenableFuture类自带的addListener(Runnable listener, Executor executor)方法注册回调函数（不推荐）
		  */
		 ExecutorService executor = Executors.newFixedThreadPool(1);
		 ListeningExecutorService service = MoreExecutors.listeningDecorator(executor);
		 MyCallable callable = new MyCallable("JayLai");
		 ListenableFuture<String> listenableFuture = service.submit(callable);
		 final long time1 = System.currentTimeMillis();
		 //异步方法
		 //注册监听，当Callable类者中call()方法执行结束，后会进入new Runnable() {	}中
		 listenableFuture.addListener(new Runnable() {	
			@Override
			public void run() {
				try {
					System.out.println("执行结果：" + listenableFuture.get());
					long time2 = System.currentTimeMillis();
					System.out.println("执行时间为：" + (time2 - time1) + "毫秒");
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (ExecutionException e) {
					e.printStackTrace();
				}
			}
		}, executor);	//注册回调函数
		System.out.println("=======main method end======");
		
	}
}

运行结果：

3 addCallback（）方法

Guava包还提供了更加便利的注册监听方法，使用Futures类中的

public static <V> void addCallback(ListenableFuture<V> future,
      FutureCallback<? super V> callback) {
    addCallback(future, callback, directExecutor());
  }

来注册回调方法，其中FutureCallback类的源码如下

public interface FutureCallback<V> {
 
  void onSuccess(@Nullable V result);
 
  void onFailure(Throwable t);
}

它具体2个方法，当Callable类成功执行结束时候，则进入onSuccess（）方法中；若失败，如遇到异常，则进入onFailure（）方法。

public class ListenableFutureApp {
	public static void main(String[] args) {
		
		/*
		 * 方法2：采用addCallback注册回调函数（推荐此法）
		 */
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		MyCallable callable = new MyCallable("JayLai");
		Future<String> future = executorService.submit(callable);
		ListenableFuture<String> listenableFuture = JdkFutureAdapters.listenInPoolThread(future);
		long time1 = System.currentTimeMillis();
		//注册回调函数
		Futures.addCallback(listenableFuture, new FutureCallback<String>() {	//异步执行
			@Override
			public void onSuccess(String result) {
				System.out.println("执行结果：" + result);
				long time2 = System.currentTimeMillis();
				System.out.println("执行时间为：" + (time2 - time1) + "毫秒");
			}
			@Override
			public void onFailure(Throwable t) {
				System.out.println("Error!!!");
			}
		});
		
		System.out.println("=====main method end !====");
	}
}

运行结果：

4 参考文献

[1] 高洪岩, Java多线程编程核心技术. 2015.
[2] http://ifeve.com/google-guava-listenablefuture/
[3] http://tool.oschina.net/apidocs/apidoc?api=guava