google Guava包的ListenableFuture解析

最新推荐文章于 2022-03-04 18:38:09 发布

原创最新推荐文章于 2022-03-04 18:38:09 发布 · 7.2k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#google Guava #ExecutorService #ListenableFuture #多线程

java核心同时被 3 个专栏收录

32 篇文章

订阅专栏

多线程

13 篇文章

订阅专栏

google Guava

2 篇文章

订阅专栏

Guava的ListenableFuture接口扩展了JDK的Future，允许注册回调方法，以便在运算完成后执行。这比JDK的Future更强大，因为它支持在完成时执行回调，提供更多的并发编程灵活性。ListenableFuture通过addListener方法添加回调，并可通过Futures.addCallback简化使用，定义onSuccess和onFailure处理成功和失败的情况。要创建ListenableFuture，可以使用ListeningExecutorService，通过MoreExecutors.listeningDecorator转换ExecutorService。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

并发编程是一个难题，但是一个强大而简单的抽象可以显著的简化并发的编写。出于这样的考虑，Guava 定义了 ListenableFuture接口并继承了JDK concurrent包下的Future 接口。

我们强烈地建议你在代码中多使用ListenableFuture来代替JDK的 Future, 因为：

大多数Futures 方法中需要它。
转到ListenableFuture 编程比较容易。
Guava提供的通用公共类封装了公共的操作方方法，不需要提供Future和ListenableFuture的扩展方法。
接口
传统JDK中的Future通过异步的方式计算返回结果:在多线程运算中可能或者可能在没有结束返回结果，Future是运行中的多线程的一个引用句柄，确保在服务执行返回一个Result。

ListenableFuture可以允许你注册回调方法(callbacks)，在运算（多线程执行）完成的时候进行调用, 或者在运算（多线程执行）完成后立即执行。这样简单的改进，使得可以明显的支持更多的操作，这样的功能在JDK concurrent中的Future是不支持的。

ListenableFuture 中的基础方法是addListener(Runnable, Executor), 该方法会在多线程运算完的时候，指定的Runnable参数传入的对象会被指定的Executor执行。

添加回调（Callbacks）
多数用户喜欢使用 Futures.addCallback(ListenableFuture<V>, FutureCallback<V>, Executor)的方式, 或者另外一个版本version（译者注：addCallback(ListenableFuture<V> future,FutureCallback<? super V> callback)），默认是采用 MoreExecutors.sameThreadExecutor()线程池, 为了简化使用，Callback采用轻量级的设计. FutureCallback<V> 中实现了两个方法:

onSuccess(V),在Future成功的时候执行，根据Future结果来判断。
onFailure(Throwable), 在Future失败的时候执行，根据Future结果来判断。
ListenableFuture的创建
对应JDK中的 ExecutorService.submit(Callable) 提交多线程异步运算的方式，Guava 提供了ListeningExecutorService 接口, 该接口返回 ListenableFuture 而相应的 ExecutorService 返回普通的 Future。将 ExecutorService 转为 ListeningExecutorService，可以使用MoreExecutors.listeningDecorator(ExecutorService)进行装饰。

ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
ListenableFuture explosion = service.submit(new Callable() {
  public Explosion call() {
    return pushBigRedButton();
  }
});
Futures.addCallback(explosion, new FutureCallback() {
  // we want this handler to run immediately after we push the big red button!
  public void onSuccess(Explosion explosion) {
    walkAwayFrom(explosion);
  }
  public void onFailure(Throwable thrown) {
    battleArchNemesis(); // escaped the explosion!
  }
});

另外, 假如你是从 FutureTask转换而来的, Guava 提供ListenableFutureTask.create(Callable<V>) 和ListenableFutureTask.create(Runnable, V). 和 JDK不同的是, ListenableFutureTask 不能随意被继承（译者注：ListenableFutureTask中的done方法实现了调用listener的操作）。

假如你喜欢抽象的方式来设置future的值，而不是想实现接口中的方法，可以考虑继承抽象类AbstractFuture<V> 或者直接使用 SettableFuture 。

假如你必须将其他API提供的Future转换成 ListenableFuture，你没有别的方法只能采用硬编码的方式JdkFutureAdapters.listenInPoolThread(Future) 来将 Future 转换成 ListenableFuture。尽可能地采用修改原生的代码返回 ListenableFuture会更好一些。

Application
使用ListenableFuture 最重要的理由是它可以进行一系列的复杂链式的异步操作。

ListenableFuture rowKeyFuture = indexService.lookUp(query);
AsyncFunction<RowKey, QueryResult> queryFunction =
	new AsyncFunction<RowKey, QueryResult>() {
		public ListenableFuture apply(RowKey rowKey) {
		return dataService.read(rowKey);
	}
};
ListenableFuture queryFuture = Futures.transform(rowKeyFuture, queryFunction, queryExecutor);

ListenableFuture queryFuture = Futures.transform(rowKeyFuture, queryFunction, queryExecutor);其他更多的操作可以更加有效的支持而JDK中的Future是没法支持的.不同的操作可以在不同的Executors中执行，单独的ListenableFuture 可以有多个操作等待。当一个操作开始的时候其他的一些操作也会尽快开始执行–“fan-out”–ListenableFuture 能够满足这样的场景：促发所有的回调（callbacks）。反之更简单的工作是，同样可以满足“fan-in”场景，促发ListenableFuture 获取（get）计算结果，同时其它的Futures也会尽快执行：可以参考 the implementation of Futures.allAsList 。（译者注：fan-in和fan-out是软件设计的一个术语，可以参考这里：http://baike.baidu.com/view/388892.htm#1或者看这里的解析Design Principles: Fan-In vs Fan-Out，这里fan-out的实现就是封装的ListenableFuture通过回调，调用其它代码片段。fan-in的意义是可以调用其它Future）

package com.share;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

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;

public class FutureCallbackExample {

	public static void main(String[] args) throws Exception {
		nativeFuture();
		Thread.sleep(3000L);

		guavaFuture();
		Thread.sleep(3000L);

		guavaFuture2();
	}


	public static void nativeFuture() throws Exception {
		// 原生的Future模式,实现异步
		ExecutorService nativeExecutor = Executors.newSingleThreadExecutor();
		Future<String> nativeFuture = nativeExecutor
				.submit(new Callable<String>() {
					@Override
					public String call() throws Exception {
						// 使用sleep模拟调用耗时
						TimeUnit.SECONDS.sleep(1);
						return  "[" + Thread.currentThread().getName()
                                                 +"]: 并发包Future返回结果" ;
					}
				});
		// Future只实现了异步，而没有实现回调.所以此时主线程get结果时阻塞.或者可以轮训以
                //便获取异步调用是否完成
		System.out.println("[" + Thread.currentThread().getName() +"]====>"+ nativeFuture.get());
		nativeExecutor.shutdown();

	}
	public static void guavaFuture() throws Exception {
	System.out.println("-------------------------------- 神秘的分割线 -----------------------------------");
		// 好的实现应该是提供回调,即异步调用完成后,可以直接回调.本例采用guava提供的异步回调接口,方便很多.
		ListeningExecutorService guavaExecutor = MoreExecutors
				.listeningDecorator(Executors.newSingleThreadExecutor());
		final ListenableFuture<String> listenableFuture = guavaExecutor
				.submit(new Callable<String>() {

					@Override
					public String call() throws Exception {
						TimeUnit.SECONDS.sleep(1);
						return  "[" + Thread.currentThread().getName() 
                                                          +"]: guava的Future返回结果";
					}
				});

		// 注册监听器,即异步调用完成时会在指定的线程池中执行注册的监听器
		listenableFuture.addListener(new Runnable() {
			@Override
			public void run() {
				try {
					String logTxt = "[" + Thread.currentThread().getName()
                                          +"]: guava对返回结果进行异步CallBack(Runnable):"
							+ listenableFuture.get();
					System.out.println(logTxt);
				} catch (Exception e) {
				}
			}
		}, Executors.newSingleThreadExecutor());

		// 主线程可以继续执行,异步完成后会执行注册的监听器任务.
		System.out.println( "[" + Thread.currentThread().getName() +"]: guavaFuture1执行结束");
		guavaExecutor.shutdown();
	}

	public static void guavaFuture2() throws Exception {
	System.out.println("-------------------------------- 神秘的分割线 -----------------------------------");
		// 除了ListenableFuture,guava还提供了FutureCallback接口,相对来说更加方便一些.
		ListeningExecutorService guavaExecutor2 = MoreExecutors
				.listeningDecorator(Executors.newSingleThreadExecutor());
		final ListenableFuture<String> listenableFuture2 = guavaExecutor2
				.submit(new Callable<String>() {
					@Override
					public String call() throws Exception {
						TimeUnit.SECONDS.sleep(1);
						String logText = "[" + Thread.currentThread().getName() 
                                                +"]: guava的Future返回结果";
						System.out.println(logText);
						return logText;
					}
				});


		// 注意这里没用指定执行回调的线程池,从输出可以看出，默认是和执行异步操作的线程是同一个
		Futures.addCallback(listenableFuture2, new FutureCallback<String>() {
					@Override
					public void onSuccess(String result) {
						String logTxt = "[" + Thread.currentThread().getName() 
              +"]=======>对回调结果【"+result+"】进行FutureCallback,经测试，发现是和回调结果处理线程为同一个线程";
						System.out.println(logTxt);
					}
					@Override
					public void onFailure(Throwable t) {
					}
				}
		);
		// 主线程可以继续执行,异步完成后会执行注册的监听器任务.
		System.out.println( "[" + Thread.currentThread().getName() +"]: guavaFuture2执行结束");
		guavaExecutor2.shutdown();
	}
}