ListenableFuture和CompletableFuture简单小结
前言
最近花了点时间熟悉了下ListenableFuture和CompletableFuture的使用。二者都是原生JDK中老版Future-Get模式的改进。本文将结合demo程序来直观的学习一下这两大Future的使用特点。
老版Future模式的缺点
老版Future模式一个最大的问题是需要获取结果做后续处理操作的时候，还是需要阻塞等待。这样的话，和同步调用方式就没有多大区别了。而ListenableFuture和CompletableFuture对于这种情况则是提供了很多易用的API。
如果说按照先后顺序来讲的话，首先是ListenableFuture，这是由Google Guava工具包提供的Future扩展类，随后，JDK在1.8版本中马上也提供了类似这样的类，就是CompletableFuture。
ListenableFuture
先来聊聊ListenableFuture，一句话概括ListenableFuture和JDK原生Future最大的区别是前者做到了一个可以监听结果的Future。换个更通俗的讲法，就是它可以监听异步执行的过程，执行完了，自动触发什么操作。除此之外，可以分别针对成功的情况，或者失败的情况做各种后续处理。具体使用可以看下面笔者写的demo程序。
package
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;
/**
* The unit test for ListenableFuture/CompletableFuture.
* Created by yiqun01.lin
* on 2018/5/3.
*/
public class TestFutures {
//线程池中线程个数
private static final int POOL_SIZE = 50;
//带有回调机制的线程池
private static final ListeningExecutorService service = MoreExecutors
.listeningDecorator(Executors.newFixedThreadPool(POOL_SIZE));
private static Logger LOG = LoggerFactory.getLogger(TestFutures.class);
@Test
public void testListenableFuture() {
final List<String> value = Collections
.synchronizedList(new ArrayList<String>());
try {
List<ListenableFuture<String>> futures = new ArrayList<ListenableFuture<String>>();
// 将实现了callable的任务放入到线程池中，得到一个带有回调机制的ListenableFuture实例，
// 通过Futures.addCallback方法对得到的ListenableFuture实例进行监听，一旦得到结果就进入到onSuccess方法中，
// 在onSuccess方法中将查询的结果存入到集合中
for (int i = 0; i < 1; i++) {
final int index = i;
if (i == 9) {
Thread.sleep(500 * i);
}
ListenableFuture<String> sfuture = service
.submit(new Callable<String>() {
@Override
public String call() throws Exception {
long time = System.currentTimeMillis();
LOG.info("Finishing sleeping task{}: {}", index, time);
return String.valueOf(time);
}
});
sfuture.addListener(new Runnable() {
@Override
public void run() {
LOG.info("Listener be triggered for task{}.", index);
}
}, service);
Futures.addCallback(sfuture, new FutureCallback<String>() {
public void onSuccess(String result) {
LOG.info("Add result value into value list {}.", result);
value.add(result);
}
public void onFailure(Throwable t) {
LOG.info("Add result value into value list error.", t);
throw new RuntimeException(t);
}
});
// 将每一次查询得到的ListenableFuture放入到集合中
futures.add(sfuture);
}
// 这里将集合中的若干ListenableFuture形成一个新的ListenableFuture
// 目的是为了异步阻塞，直到所有的ListenableFuture都得到结果才继续当前线程
// 这里的时间取的是所有任务中用时最长的一个
ListenableFuture<List<String>> allAsList = Futures.allAsList(futures);
allAsList.get();
LOG.info("All sub-task are finished.");
} catch (Exception ignored) {
}
}
@Test
public void testCompletableFuture() throws Exception {
...
}
}根据测试输出结果，来验证其中的执行顺序，是不是我们预期的那样。
2018-05-19 11:06:34,870 [pool-1-thread-1] INFO records.TestFutures (TestFutures.java:call(53)) - Finishing sleeping task0: 1526699194868
2018-05-19 11:06:34,874 [pool-1-thread-2] INFO records.TestFutures (TestFutures.java:run(60)) - Listener be triggered for task0.
2018-05-19 11:06:34,896 [main] INFO records.TestFutures (TestFutures.java:onSuccess(66)) - Add result value into value list 1526699194868.
2018-05-19 11:06:34,924 [main] INFO records.TestFutures (TestFutures.java:testListenableFuture(84)) - All sub-task are finished.CompletableFuture
我们再来看看CompletableFuture的使用，这个是在JDK8中开始引入的，这个在一定程度上与ListenableFuture非常类似。比如说ListenableFuture的listener监听回调，在这个类中，相当于thenRun或者whneComplete操作原语。CompletableFuture提供的API其实有很多，从大的方向上来划分的话，有下面几类：
public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)注意到这里，runAsync是不带类型返回的，Void，而supplyAsync API需要传入类型的，整型，字符串或者其它，然后是否需要在额外的线程池里执行这些Async操作，如果没有指定，会默认在ForkJoinPool提供的common pool里跑。
同样笔者也写了一个简单的demo程序：
package
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;
/**
* The unit test for ListenableFuture/CompletableFuture.
* Created by yiqun01.lin
* on 2018/5/3.
*/
public class TestFutures {
//线程池中线程个数
private static final int POOL_SIZE = 50;
//带有回调机制的线程池
private static final ListeningExecutorService service = MoreExecutors
.listeningDecorator(Executors.newFixedThreadPool(POOL_SIZE));
private static Logger LOG = LoggerFactory.getLogger(TestFutures.class);
@Test
public void testListenableFuture() {
...
}
@Test
public void testCompletableFuture() throws Exception {
// case1: supplyAsync
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
LOG.info("Run supplyAsync.");
return "Return result of Supply Async";
});
// case2: thenRun，与supplyAsync同线程
future.thenRun(new Runnable() {
@Override
public void run() {
LOG.info("Run action.");
}
});
// case2: thenRunAsync，另启动线程执行
future.thenRunAsync(new Runnable() {
@Override
public void run() {
LOG.info("Run async action.");
}
});
// 主动触发Complete结束方法
// future.complete("Manual complete value.");
future.whenComplete((v, e) -> {
LOG.info("WhenComplete value: " + v);
LOG.info("WhenComplete exception: " + e);
});
CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
LOG.info("Return result of Run Async.");
});
CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
return "hello";
});
CompletableFuture<String> future4 = CompletableFuture.supplyAsync(() -> {
return "world";
});
CompletableFuture<String> f = future3.thenCombine(future4,
(x, y) -> x + "-" + y);
LOG.info(f.get());
}
}测试输出结果：
2018-05-19 11:16:36,358 [ForkJoinPool.commonPool-worker-1] INFO records.TestFutures (TestFutures.java:lambda$0(93)) - Run supplyAsync.
2018-05-19 11:16:36,381 [main] INFO records.TestFutures (TestFutures.java:run(102)) - Run action.
2018-05-19 11:16:36,393 [ForkJoinPool.commonPool-worker-1] INFO records.TestFutures (TestFutures.java:run(111)) - Run async action.
2018-05-19 11:16:36,394 [main] INFO records.TestFutures (TestFutures.java:lambda$1(118)) - WhenComplete value: Return result of Supply Async
2018-05-19 11:16:36,394 [main] INFO records.TestFutures (TestFutures.java:lambda$1(119)) - WhenComplete exception: null
2018-05-19 11:16:36,396 [ForkJoinPool.commonPool-worker-1] INFO records.TestFutures (TestFutures.java:lambda$2(122)) - Return result of Run Async.
2018-05-19 11:16:36,397 [main] INFO records.TestFutures (TestFutures.java:testCompletableFuture(133)) - hello-world这些API使用起来还是非常灵活的，大家可以自行本地继续调试调试，包括哪些是阻塞执行的，哪些是异步的，哪些是需要额外开线程执行的等等。
