【JUC】CompletableFuture对Future的改进
【JUC】CompletableFuture对Future的改进
文章目录
- 【JUC】CompletableFuture对Future的改进
-
- 1. Future弊端
- 2. CompletableFuture
-
- 2.1 核心方法
- 2.2 优点
- 2.3 get()和join()的区别
- 3. CompletableFuture常用方法
-
- 3.1 获得结果和触发计算
- 3.2 对计算结果进行处理
-
- 3.2.1 thenApply(Function fn)
- 3.2.2 handle(BiFunction fn)
- 3.2.3 问题
- 3.3 对计算结果进行消费
-
- 3.3.1 thenApply(Function fn)
- 3.3.2 任务之间的顺序执行
- 3.4 对计算速度进行选用
-
- 3.4.1 applyToEither(CompletionStage other, Function fn)
- 3.5 对计算结果进行合并
-
- 3.5.1 thenCombine(CompletionStage other,BiFunction fn)
1. Future弊端
- 阻塞
- cpu空转
1）想要得到Future任务的结果,使用 get() 方法阻塞线程直到结果返回。
FutureTask<String> futureTask = new FutureTask<String>(() -> {
System.out.println(Thread.currentThread().getName() + "\t -----come in");
//暂停几秒钟线程
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "task over";
});
Thread t1 = new Thread(futureTask, "t1");
t1.start();
System.out.println(Thread.currentThread().getName() + "\t ----忙其它任务了");
System.out.println(futureTask.get());
2）不想阻塞那就采用 isDone()轮询,轮询的方式会耗费无谓的cpu资源，而且也不见得能够及时获得结果。
FutureTask<String> futureTask = new FutureTask<String>(() -> {
System.out.println(Thread.currentThread().getName() + "\t -----come in");
//暂停几秒钟线程
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "task over";
});
Thread t1 = new Thread(futureTask, "t1");
t1.start();
System.out.println(Thread.currentThread().getName() + "\t ----忙其它任务了");
while (true){
if(futureTask.isDone()){
System.out.println(futureTask.get());
break;
}else {
//暂停毫秒
TimeUnit.MILLISECONDS.sleep(500);
System.out.println("正在处理中，不要再催了！");
}
}
这两种方法都违背了“异步”思想。所以我们需要一个更加强大的类去实现方法的“异步”执行。于是就有了 CompletableFuture 。
2. CompletableFuture
在java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。
它可能代表一个明确完成的 Future，也有可能代表一个完成阶段（CompletionStage） ，它支持在计算完成以后触发一些函数或执行某些动作。
它还实现了Future和CompletionStage接口。
2.1 核心方法
CompletableFuture提供了核心的四个静态方法来创建一个异步操作：
- runAsync无返回值：public static CompletableFuture runAsync(Runnable runnable)
- runAsync无返回值：public static CompletableFuture runAsync(Runnable runnable,Executor executor)
- supplyAsync有返回值：public static CompletableFuture supplyAsync(Supplier supplier)
- supplyAsync有返回值：public static CompletableFuture supplyAsync(Supplier supplier,Executor executor)
如果指定了线程池则使用自己的线程池，没有的话默认使用系统提供的。
1）runAsync无返回值，不指定线程池
//方式1,没有返回值，并且不指定线程池
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
System.out.println(Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println(completableFuture.get());
2）runAsync无返回值，指定线程池
//方式2，有返回值，并且指定线程池
ExecutorService threadPool = Executors.newFixedThreadPool(3);
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
System.out.println(Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
},threadPool);
System.out.println(completableFuture.get());
//关闭线程池
threadPool.shutdown();
3）supplyAsync有返回值，不指定线程池
//方式3，有返回值，不指定线程池
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "hello world";
});
System.out.println(completableFuture.get());
4）supplyAsync有返回值，指定线程池
//方式4，有返回值，指定线程池
ExecutorService threadPool = Executors.newFixedThreadPool(3);
CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "hello world";
},threadPool);
System.out.println(completableFuture.get());
//关闭线程池
threadPool.shutdown();
从Java8开始引入了CompletableFuture，它是Future的增强版，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。
2.2 优点
CompletableFuture有很多优点，比如：
- 异步任务结束时，会自动回调某个对象的方法。
- 异步任务出错时，会自动回调某个对象的方法。
- 主线程设置好回调后，不再关心异步任务的执行，异步任务之间可以顺序执行。
public static void main(String[] args) throws ExecutionException, InterruptedException {
//future1();
ExecutorService threadPool = Executors.newFixedThreadPool(3);
try {
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
//异步任务。。。
log.info("当前线程名：{}", Thread.currentThread().getName());
//int i=1/0;
int result = ThreadLocalRandom.current().nextInt(10);
log.info("----3s后出结果：{}", result);
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
return result;
}, threadPool).whenComplete((v, e) -> {
//回调方法
if (e == null) {
log.info("计算完成，更新updateValue值为:{}", v);
}
}).exceptionally(e -> {
//发生错误时的回调方法
e.printStackTrace();
log.info("异常情况：{},\\t{}", e.getCause(), e.getMessage());
return null;
});
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();
}
log.info("{}线程先去忙别的任务了", Thread.currentThread().getName());
}
这种写法和js的请求方法回调类似。在 whenComplete 中执行任务正常完成后的操作，在 exceptionally 中执行任务发生异常后的操作。
2.3 get()和join()的区别
在Java的CompletableFuture类中，get()和join()也都是用于获取Future的执行结果的方法。它们的主要区别在于返回值和异常处理上。
join()方法会等待当前CompletableFuture对象的执行结果，如果执行过程中出现了异常，则会抛出Unchecked Exception。
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
//do something and return result
return result;
});
String result = future.join(); //等待future执行完毕，获取结果
//如果future执行过程中出现了异常，则会抛出Unchecked Exception
get()方法也会等待当前CompletableFuture对象的执行结果，但不同的是，如果执行过程中出现了异常，则会抛出Checked Exception（ExecutionException），这需要进行捕获或者声明抛出。
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
//do something and return result
return result;
});
try {
String result = future.get(); //等待future执行完毕，获取结果
} catch (InterruptedException e) {
//处理InterruptedException异常
} catch (ExecutionException e) {
//处理ExecutionException异常
}
如果你不想在代码中显式地处理异常，并且可以确定CompletableFuture执行过程中不会出现异常，那么可以使用join()方法。否则，如果你需要对执行过程中出现的异常进行处理，可以使用get()方法。
3. CompletableFuture常用方法
3.1 获得结果和触发计算
获取结果：
public T getNow(T valueIfAbsent)：立刻返回结果，没有计算完成的情况下给一个替代的结果(valueIfAbsent)。
主动触发计算：
public boolean complete(T value)：没有计算完成则打断任务并将结果设置为value。
3.2 对计算结果进行处理
3.2.1 thenApply(Function fn)
thenApply：计算结果存在依赖关系，线程之间串行化，由于存在依赖关系，如果当前计算过程出错，则不会走到下一过程计算。
方法如下：
public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn) {
return uniApplyStage(null, fn);
}
示例：
@Test
public void test() {
long start = System.currentTimeMillis();
//当一个线程依赖另一个线程时用 thenApply 方法来把这两个线程串行化,
CompletableFuture.supplyAsync(() -> {
//暂停几秒钟线程
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("111");
return 1024;
}).thenApply(f -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("222");
return f + 1;
}).thenApply(f -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//int age = 10/0; // 异常情况：那步出错就停在那步。
System.out.println("333");
return f + 1;
}).whenCompleteAsync((v, e) -> {
System.out.println("*****v: " + v);
long end = System.currentTimeMillis();
System.out.println("耗时：" + (end - start)+"ms");
}).exceptionally(e -> {
e.printStackTrace();
return null;
});
System.out.println("-----主线程结束，END");
// 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
运行结果：
3.2.2 handle(BiFunction fn)
handle：计算结果存在依赖关系，线程之间串行化，当前计算过程有错则跳过，直接进入下一计算过程。
public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn) {
return uniHandleStage(null, fn);
}
示例：
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
CompletableFuture.supplyAsync(() -> {
//暂停几秒钟线程
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("111");
return 1;
}, threadPool).handle((f, e) -> {
int i = 10 / 0;
System.out.println("222");
return f + 2;
}).handle((f, e) -> {
System.out.println("333");
return f + 3;
}).whenComplete((v, e) -> {
if (e == null) {
System.out.println("----计算结果： " + v);
}
}).exceptionally(e -> {
e.printStackTrace();
System.out.println(e.getMessage());
return null;
});
System.out.println(Thread.currentThread().getName() + "----主线程先去忙其它任务");
threadPool.shutdown();
}
运行结果：
3.2.3 问题
whenComplete()和whenCompleteAsync()的区别：
whenComplete()方法是在当前线程中执行回调操作，即会阻塞当前线程直到回调操作执行完毕。如果异步任务已经完成，则立即执行回调操作；否则等待异步任务完成后再执行回调操作。whenComplete()方法是在当前线程中执行回调操作，即会阻塞当前线程直到回调操作执行完毕。如果异步任务已经完成，则立即执行回调操作；否则等待异步任务完成后再执行回调操作。- 因此，
whenComplete()方法会阻塞当前线程，而whenCompleteAsync()方法不会阻塞当前线程，会在新的线程中执行回调操作。
3.3 对计算结果进行消费
接受任务的处理结果并消费，无返回结果。
3.3.1 thenApply(Function fn)
public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn) {
return uniApplyStage(null, fn);
}
示例：
@Test
public void test(){
CompletableFuture.supplyAsync(() -> {
return 1;
}).thenApply(f -> {
return f + 2;
}).thenApply(f -> {
return f + 3;
}).thenApply(f -> {
return f + 4;
}).thenAccept(r -> System.out.println(r));
}
运行结果为:10
3.3.2 任务之间的顺序执行
thenRun(Runnable runnable)：任务A执行完再执行B，并且B不需要A的结果
thenAccept(Consumer action)：任务A执行完再执行B，B需要A的结果，B无返回值
thenApply(Function fn)：任务A执行完再执行B，B需要A的结果，B有返回值
示例：
public static void main(String[] args){
System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenRun(() -> {}).join());
System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenAccept(r -> System.out.println(r)).join());
System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenApply(r -> r + "resultB").join());
}
运行结果如下：
3.4 对计算速度进行选用
谁快就用谁
3.4.1 applyToEither(CompletionStage other, Function fn)
方法如下：
public <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn) {
return orApplyStage(null, other, fn);
}
示例：
public static void main(String[] args)
{
CompletableFuture<String> playA = CompletableFuture.supplyAsync(() -> {
System.out.println("A come in");
try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
return "playA";
});
CompletableFuture<String> playB = CompletableFuture.supplyAsync(() -> {
System.out.println("B come in");
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
return "playB";
});
CompletableFuture<String> result = playA.applyToEither(playB, f -> {
return f + " is winer";
});
System.out.println(Thread.currentThread().getName()+"\t"+"-----: "+result.join());
}
运行结果如下：
3.5 对计算结果进行合并
3.5.1 thenCombine(CompletionStage other,BiFunction fn)
作用：返回一个新的CompletionStage，当该阶段和另一个给定阶段都正常完成时，该阶段将以两个结果作为所提供函数的参数执行。
方法如下：
public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn) {
return biApplyStage(null, other, fn);
}
示例：
public static void main(String[] args) {
CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(() -> {
log.info("{}\t ---A启动" + Thread.currentThread().getName());
//暂停几秒钟线程
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 20;
});
CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
log.info("{}\t ---B启动" + Thread.currentThread().getName());
//暂停几秒钟线程
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 10;
});
CompletableFuture<Integer> result = completableFuture1.thenCombine(completableFuture2, (x, y) -> {
log.info("-----开始两个结果合并");
return x + y;
});
log.info("{}",result.join());
}
运行结果如下：
