JUC并发编程（1）—CompletableFuture详解
最近在学习juc并发编程，于是决定汇总一下并发编程中常用方法，常见问题以及常见考题，今天是第一章—CompletableFuture
CompletableFuture介绍
CompletableFuture是jdk8版本开始出现的类。目的是为了应用于并发编程状态下遇到的各种场景。CompletableFuture实现了CompletionStage接口和Future接口，对Java7及以前Future接口做了大量的扩展，增加了许多常用方法，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。
首先得学会看懂几个函数式接口的特性！！！（重点）
1.创建异步任务
//runAsync方法不支持返回值
public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
//supplyAsync可以支持返回值
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)
CompletableFuture创建异步任务主要分为两个方法runAsync和supplyAsync
其中
- runAsync方法不支持返回值
- supplyAsync可以支持返回值(常用）
- 没有指定Executor的方法会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池,则使用指定的线程池运行。
下面是四种创建方式
public class CompletableFutureTest {
public static void main(String[] args) throws Exception{
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5,5,5
TimeUnit.MINUTES,
new LinkedBlockingQueue<>(10));
CompletableFuture future1=CompletableFuture.runAsync(()->{
System.out.println(Thread.currentThread().getName()+"*********future1 coming in");
});
//这里获取到的值是null,无返回值
System.out.println(future1.get());
CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
//ForkJoinPool.commonPool-worker-9
System.out.println(Thread.currentThread().getName() + "\t" + "*********future2 coming in");
}, executor);
CompletableFuture<Integer> future3 =CompletableFuture.supplyAsync(()-> {
//pool-1-thread-1
System.out.println(Thread.currentThread().getName() + "\t" + "future3带有返回值");
return "abc";
});
System.out.println(future3.get());
CompletableFuture<Integer> future4 = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread().getName() + "\t" + "future4带有返回值");
return "abc";
}, executor);
System.out.println(future4.get());
//关闭线程池
executor.shutdown();
}
}
2.CompletableFuture API
①. 获得结果和触发计算(get、getNow、join、complete)
获得结果和触发计算(get、getNow、join、complete)
- public T get( )：不见不散(会抛出异常) 只要调用了get( )方法,不管是否计算完成都会导致阻塞
- public T get(long timeout, TimeUnit unit)：过时不候
- public T getNow(T valuelfAbsent)：没有计算完成的情况下,给我一个替代结果计算完,返回计算完成后的结果、没算完,返回设定的valuelfAbsent
- public T join( )：join方法和get( )方法作用一样,唯一区别是join方法编译时不需要手动抛异常
- public CompletableFuture thenApply：计算结果存在依赖关系,这两个线程串行化，由于存在依赖关系(当前步错,不走下一步),当前步骤有异常的话就叫停
- public CompletableFuture handle(BiFunction<? super T, Throwable, ? extends U> fn):有异常也可以往下一步走,根据带的异常参数可以进一步处理
- whenComplete:是执行当前任务的线程执行继续执行whenComplete的任务
- whenCompleteAsync:是执行把whenCompleteAsync这个任务继续提交给线程池来进行执行
②. 对计算结果进行处理(thenApply、handle)
- public CompletableFuture thenApply：计算结果存在依赖关系,这两个线程串行化由于存在依赖关系(当前步错,不走下一步),当前步骤有异常的话就叫停
- public CompletableFuture handle(BiFunction<? super T, Throwable, ? extends U> fn):有异常也可以往下一步走,根据带的异常参数可以进一步处理
- whenComplete:是执行当前任务的线程执行继续执行whenComplete的任务
- whenCompleteAsync:是执行把whenCompleteAsync这个任务继续提交给线程池来进行执行
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {e.printStackTrace();}
return 1;
}).thenApply(s->{
System.out.println("-----1");
//如果加上int error=1/0; 由于存在依赖关系(当前步错,不走下一步),当前步骤有异常的话就叫停
//int error=1/0;
return s+1;
}).thenApply(s->{
System.out.println("-----2");
return s+2;
}).whenComplete((v,e)->{
if(e==null){
System.out.println("result-----"+v);
}
}).exceptionally(e->{
e.printStackTrace();
return null;
});
System.out.println(Thread.currentThread().getName()+"\t"+"over....");
try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) {e.printStackTrace();}
CompletableFuture.supplyAsync(() -> {
return 1;
}).handle((f,e) -> {
System.out.println("-----1");
return f + 2;
}).handle((f,e) -> {
System.out.println("-----2");
int error=1/0;
return f + 3;
}).handle((f,e) -> {
System.out.println("-----3");
return f + 4;
}).whenComplete((v, e) -> {
if (e == null) {
System.out.println("----result: " + v);
}
}).exceptionally(e -> {
e.printStackTrace();
return null;
}).join());
③. 对计算结果进行消费(thenRun、thenAccept、thenApply)
- thenRun(Runnable runnable)
任务A执行完执行B,并且B不需要A的结果 - CompletableFutur thenAccept(Consumer<? super T> action)
任务A执行完成执行B,B需要A的结果,但是任务B无返回值 - public CompletableFuture thenApply(Function<? super T,? extends U> fn)
4. 线程串行化方法
带了Async的方法表示的是:会重新在线程池中启动一个线程来执行任务
public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)
public CompletableFuture<Void> thenAccept(Consumer<? super T> action)
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action)
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor)
public CompletableFuture<Void> thenRun(Runnable action)
public CompletableFuture<Void> thenRunAsync(Runnable action)
public CompletableFuture<Void> thenRunAsync(Runnable action,Executor executor)
④. 对计算速度进行选用(applyToEither、acceptEither、runAfterEither)
- public CompletableFuture applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn)
这个方法表示的是,谁完成任务完成的快就返回谁的结果
- 两任务组合,一个完成
applyToEither:两个任务有一个执行完成,获取它的返回值,处理任务并有新的返回值
acceptEither:两个任务有一个执行完成,获取它的返回值,处理任务,没有新的返回值
runAfterEither:两个任务有一个执行完成,不需要获取 future 的结果,处理任务,也没有返回值
⑤. 对计算结果进行合并(thenCombine、thenAcceptBoth、runAfterBoth)
- public <U,V> CompletableFuture thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn)
两个CompletionStage任务都完成后,最终把两个任务的结果一起交给thenCombine来处理先完成的先等着,等待其他分支任务
⑥. 多任务组合(allOf、anyOf)
- allOf:等待所有任务完成
(public static CompletableFuture allOf(CompletableFuture<?>… cfs)) - anyOf:只要有一个任务完成
(public static CompletableFuture anyOf(CompletableFuture<?>… cfs))
实战演练
案例说明:电商比价需求
同一款产品,同时搜索出同款产品在各大电商的售价;
同一款产品,同时搜索出本产品在某一个电商平台下,各个入驻门店的售价是多少
出来结果希望是同款产品的在不同地方的价格清单列表,返回一个List
in jd price is 88.05
in pdd price is 86.11
in taobao price is 90.43
(String类型)
代码示例
public class test1 {
public ExecutorService executorService = new ThreadPoolExecutor(40,100,100,TimeUnit.MINUTES,new ArrayBlockingQueue<>(10000));
public static List<mall> list = Arrays.asList(
new mall("jd"),
new mall("tmall"),
new mall("taobao"),
new mall("pdd"),
new mall("elm")
);
public static void main(String[] args) {
showRes3(list,"mysql");
}
public static List<String> showRes(List<mall> list,String productName){
long start = System.currentTimeMillis();
List<String> collect = list.stream().map(mall -> String.format(productName + " in %s price is %.2f", mall.getName(), mall.getPrice(productName))).collect(Collectors.toList());
collect.forEach(System.out::println);
long end = System.currentTimeMillis();
System.out.println("耗时："+(end-start)+"秒");
return collect;
}
public static List<String> showRes2(List<mall> list,String productName){
long start = System.currentTimeMillis();
List<String> collect = list.parallelStream().map(mall -> CompletableFuture.supplyAsync(() ->
String.format(productName + " in %s price is %.2f", mall.getName(), mall.getPrice(productName))
).join()).collect(Collectors.toList());
long end = System.currentTimeMillis();
collect.forEach(System.out::println);
System.out.println("耗时："+(end-start)+"秒");
return collect;
}
public static List<String> showRes3(List<mall> list,String productName){
long start = System.currentTimeMillis();
List<String> collect = list.stream().map(mall -> CompletableFuture.supplyAsync(() -> String.format(productName + " in %s price is %.2f", mall.getName(), mall.getPrice(productName))
)).collect(Collectors.toList()).stream().map(s -> s.join()).collect(Collectors.toList());
long end = System.currentTimeMillis();
collect.forEach(System.out::println);
System.out.println("耗时："+(end-start)+"毫秒");
return collect;
}
}
class mall{
private String name;
public String getName() {
return name;
}
public mall(String name) {
this.name = name;
}
public double getPrice(String productName){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
return ThreadLocalRandom.current().nextDouble()*2+productName.charAt(0);
}
}
通过上面代码示例结果得知
通过异步线程方法耗时需要1000毫秒左右
而同步线程方法耗时需要5000毫秒
而且当商城店铺越来越多的时候，异步线程耗时不会增加，同步线程耗时会不断增加，异步的优势就显现出来了。
tips
在使用stream流的时候，如果使用的是集合的stream（）方法，再使用异步线程时比如使用join()方法会出现串行，和上面方法三一样得使用两次stream流才能实现异步执行，相当于每一步都得使用stream流。
这个时候可以使用parallelStream并行流就可以解决这个问题
但是使用parallelStream会出现一些问题，所以并行流要谨慎使用！！！
并行流的陷阱
- 线程安全
由于并行流使用多线程，则一切线程安全问题都应该是需要考虑的问题，如：资源竞争、死锁、事务、可见性等等。 - 线程消费
在虚拟机启动时，我们指定了worker线程的数量，整个程序的生命周期都将使用这些工作线程；这必然存在任务生产和消费的问题，如果某个生产者生产了许多重量级的任务（耗时很长），那么其他任务毫无疑问将会没有工作线程可用；更可怕的事情是这些工作线程正在进行IO阻塞。
1211
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
