Future&CompletableFuture使用详解
1、Future
1.1 Callable和Runnable的区别
- Callable有返回值，Runnable无返回值
- Callable可以抛出异常，Runnable无法抛出异常
@FunctionalInterface
public interface Runnable {
//执行run方法，无返回值
public abstract void run();
}
@FunctionalInterface
public interface Callable<V> {
//计算出结果，或者在无法完成时抛出异常(有返回值V)
V call() throws Exception;
}
1.2 Future
1.2.1 Future的方法
public interface Future<V> {
//尝试中断线程任务，如果任务已完成该接口调用将返回false,执行中或未开始的任务中断或不在运行
boolean cancel(boolean mayInterruptIfRunning);
//任务完成前被取消则返回ture
boolean isCancelled();
//判断任务是否已完成
boolean isDone();
//阻塞等待任务结果
V get() throws InterruptedException, ExecutionException;
//阻塞等待任务结果，超时timeout则抛出异常
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
1.2.2 Future的常规用法
JDK源码中，Doug Lea提供了2种标准的Future用法
interface ArchiveSearcher { String search(String target); }
class App {
ExecutorService executor = ...//线程池
ArchiveSearcher searcher = ...//
void showSearch(final String target) throws InterruptedException {
Future<String> future = executor.submit(new Callable<String>() {
@Override
public String call() {
return searcher.search(target);
}});
displayOtherThings(); // do other things while searching
try {
displayText(future.get()); // use future 阻塞获取即如果
} catch (ExecutionException ex) { cleanup(); return; }
}
}
通过FutureTask创建任务future，交给线程池执行
FutureTask<String> future =
new FutureTask<String>(new Callable<String>() {
public String call() {
return searcher.search(target);
}});
executor.execute(future);
1.3 FutureTask
1.3.1 FutureTask的使用方法
- FutureTask实现了Runnable和Future，既可以通过Runnable的方式执行，也可以通过Callable的方式获取结果。
- FutureTask可以作为消费者和生产者的桥梁。由生产者提交任务，消费者等待future的结果(future.get())
public class FutureUseMyDemo {
static ExecutorService executorService = Executors.newFixedThreadPool(3);
public static void main(String[] args) {
FutureTask futureTask1 = new FutureTask(new T1Task("飞刀"));
FutureTask futureTask2 = new FutureTask(new T2Task());
FutureTask futureTask3 = new FutureTask(new T3Task());
executorService.submit(futureTask1);
executorService.submit(futureTask2);
executorService.submit(futureTask3);
try {
System.out.println(futureTask1.get());
System.out.println(futureTask2.get());
System.out.println(futureTask3.get());
} catch (Exception e) {
e.printStackTrace();
}
executorService.shutdown();
}
static class T1Task implements Callable<String> {
private String extraName;
public T1Task(String plusName){
this.extraName = plusName;
}
@Override
public String call() throws Exception {
TimeUnit.SECONDS.sleep(2);
return "小李"+extraName;
}
}
static class T2Task implements Callable<String>{
@Override
public String call() throws Exception {
TimeUnit.SECONDS.sleep(3);
return "张三";
}
}
static class T3Task implements Callable<String>{
@Override
public String call() throws Exception {
TimeUnit.SECONDS.sleep(5);
return "王五";
}
}
}
1.3.2 FutureTask使用注意事项
- 当 for 循环批量获取 Future#get()容易 block时，可以使用get(timeout)保证不产生死锁
- Future 的生命周期不能后退
1.3.3 FutureTask的局限性
- 并发执行多任务时，get()结果时线程只能等待
- 无法对多个任务执行链式调用，A任务结束之后开始执行B任务
- 无法组合多个任务，Future无法保证在运行多个任务全部执行结束后执行特定动作
- 没有关于异常的处理方法
2、CompletionService
2.1 CompletionService的原理和优点
- 内部通过阻塞队列+FutureTask，实现了任务先完成先获取结果，按顺序获取排序排序。
- 内部有先进先出的阻塞队列，用于保存已经执行完成的Future
- take()或poll()方法，拿到已完成的Future
- Future#get()接口获取最终结果
2.2 应用场景
2.2.1 常用方式
public class CompletionServiceDemo {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建线程池
ExecutorService executor = Executors.newFixedThreadPool(10);
//创建CompletionService
CompletionService<Integer> cs = new ExecutorCompletionService<>(executor);
//异步向电商S1询价
cs.submit(() -> getPriceByS1());
//异步向电商S2询价
cs.submit(() -> getPriceByS2());
//异步向电商S3询价
cs.submit(() -> getPriceByS3());
//将询价结果异步保存到数据库
for (int i = 0; i < 3; i++) {
//从阻塞队列获取futureTask
Integer r = cs.take().get();
executor.execute(() -> save(r));
}
executor.shutdown();
}
private static void save(Integer r) {
log.debug("保存询价结果:{}",r);
}
private static Integer getPriceByS1() throws InterruptedException {
TimeUnit.MILLISECONDS.sleep(5000);
log.debug("电商S1询价信息1200");
return 1200;
}
private static Integer getPriceByS2() throws InterruptedException {
TimeUnit.MILLISECONDS.sleep(8000);
log.debug("电商S2询价信息1000");
return 1000;
}
private static Integer getPriceByS3() throws InterruptedException {
TimeUnit.MILLISECONDS.sleep(3000);
log.debug("电商S3询价信息800");
return 800;
}
}
2.2.2 Dubbo Forking集群模式，单个任务成功时就返回
public class CompletionServiceDemo2 {
public static void main(String[] args){
Instant now = Instant.now();
Object address = geocoder("address");
System.out.println(Duration.between(now, Instant.now()));
}
@SneakyThrows
public static Object geocoder(String addr){
//创建线程池
ExecutorService executor = Executors.newFixedThreadPool(10);
//创建CompletionService
CompletionService<Boolean> cs = new ExecutorCompletionService<>(executor);
//并行执行3个查询任务，当有1个任务获取结果后，则return
cs.submit(() -> geocoderByS1(addr));
cs.submit(() -> geocoderByS2(addr));
cs.submit(() -> geocoderByS3(addr));
Instant now = Instant.now();
/* for (int i = 0; i < 3; i++) {
//此处可以看到take()方法也是阻塞式的
System.out.println(cs.take().get());
System.out.println(Duration.between(now, Instant.now()));
}*/
return cs.take().get();
}
@SneakyThrows
public static Boolean geocoderByS1(String addr) {
TimeUnit.SECONDS.sleep(5);
return true;
}
@SneakyThrows
public static Boolean geocoderByS2(String addr) {
TimeUnit.SECONDS.sleep(8);
return true;
}
@SneakyThrows
public static Boolean geocoderByS3(String addr){
TimeUnit.SECONDS.sleep(2);
return true;
}
}
#PrintResult
PT2.054S
-
批量提交异步任务时，可以使用CompletionService
-
CompletionService将线程池Executor和阻塞队列BlockingQueue的功能融合在了一
起，能够让批量异步任务的管理更简单
-
CompletionService能够让异步任务的执行结果有序化。先执行完的先进入阻塞队列。
-
线程池隔离。CompletionService支持自己创建线程池，这种隔离性能避免几个特别耗时的任务拖垮整个应用的风险。
3、CompletableFuture
3.1 CompletableFuture特点
- CompletableFuture支持业务逻辑处理存在串行[依赖]、并行、聚合的关系
- CompletableFuture是Future接口的扩展和增强
- CompletableFuture实现了对任务的编排能力
- 默认线程池：ForkJoinPool.commonPool()
3.1 应用场景
- 描述依赖关系：
- thenApply() 把前面异步任务的结果，交给后面的Function
- thenCompose()用来连接两个有依赖关系的任务，结果由第二个任务返回
- 描述and聚合关系：
- thenCombine:任务合并，有返回值
- thenAccepetBoth:两个任务执行完成后，将结果交给thenAccepetBoth消耗，无返回值
- runAfterBoth:两个任务都执行完成后，执行下一步操作（Runnable）。
- 描述or聚合关系：
- applyToEither:两个任务谁执行的快，就使用那一个结果，有返回值。
- acceptEither: 两个任务谁执行的快，就消耗那一个结果，无返回值。
- runAfterEither: 任意一个任务执行完成，进行下一步操作(Runnable)。
- 并行执行：
- CompletableFuture类自己也提供了anyOf()和allOf()用于支持多个CompletableFuture并行执行
3.2 常用方法总结
- runAsync 方法以Runnable函数式接口类型为参数，没有返回结果，
- supplyAsync 方法Supplier函数式接口类型为参数，返回结果类型为U；Supplier 接口的 get() 方法是有返回值的（会阻塞）
- join()和get()方法都是用来获取CompletableFuture异步之后的返回值,join()方法抛出的是uncheck异常,get()方法抛出的是经过检查的异常，ExecutionException, InterruptedException 需要用户手动处理
3.3 使用案例
public static void main(String[] args) throws ExecutionException, InterruptedException {
Runnable runnable = () -> System.out.println("执行无返回结果的异步任务");
CompletableFuture.runAsync(runnable);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
System.out.println("执行有返回值的异步任务");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Hello World";
});
String result = future.join();
System.out.println(result);
}
pletableFuture.supplyAsync(() -> {
System.out.println("执行有返回值的异步任务");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Hello World";
});
String result = future.join();
System.out.println(result);
}
689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
