package com.ray.test;
import com.alibaba.fastjson.TypeReference;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadTest {
public static ExecutorService executor = Executors.newFixedThreadPool(10);
/**
* 异步编排、任务组合
*/
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("主线程开始:"+Thread.currentThread().getName());
ThreadTest test = new ThreadTest();
test.fun4();
System.out.println("主线程结束:"+Thread.currentThread().getName());
}
//有、无返回值
public void fun1() throws ExecutionException, InterruptedException {
//异步编排 无返回值
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
System.out.println("当前线程:"+Thread.currentThread().getName());
int i = 10 / 2;
System.out.println("结果运行:" + i);
}, executor);
//有返回值
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程:" + Thread.currentThread().getName());
int i = 10 / 2;
System.out.println("结果运行:" + i);
return i;
}, executor).exceptionally(throwable -> {
//处理异常
return 10;
});
System.out.println(future2.get());
//有返回值,handle处理结果
CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程:" + Thread.currentThread().getName());
int i = 10 / 2;
System.out.println("结果运行:" + i);
return i;
}, executor).handle((result, throwable) -> {
if(result != null){
return result * 2;
}
if(throwable != null){
return 20;
}
return result;
});
System.out.println(future3.get()+"--future3");
}
/**
* 串行化 A执行后 -》 B执行
* 带Async的意思是:再开一个线程; 否则和A线程共用一个线程(测试出来是主线程)
*/
public void fun2() throws ExecutionException, InterruptedException {
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程:" + Thread.currentThread().getName());
int i = 10 / 2;
return i;
}, executor).thenAccept(result -> {
System.out.println("--当前线程:" + Thread.currentThread().getName());
System.out.println("thenAcceptAsync 获取上一步结果,无返回值,result:" + result);
}).thenRunAsync(() -> {
System.out.println("--当前线程:" + Thread.currentThread().getName());
System.out.println("thenRunAsync 无结果,无返回值");
}, executor).thenApplyAsync((result) -> {
return result + "haha:thenApplyAsync获取返回值并处理返回";
}, executor);
System.out.println(future2.get());
}
/**
* 多任务组合
*/
public void fun4() throws ExecutionException, InterruptedException {
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println("查询商品的图片信息……");
return "hello.jpg";
}, executor);
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println("查询商品的属性……");
return "黑色 2+64G";
}, executor);
CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(3000);
System.out.println("查询商品的介绍……");//模拟业务时间超长
} catch (InterruptedException e) {
e.printStackTrace();
}
return "apple";
}, executor);
//allOf所有执行完后执行
CompletableFuture<Void> future4 = CompletableFuture.allOf(future1, future2, future3);
future4.get();
System.out.println(future1.get() + future2.get() + future3.get());
//anyOf() 只要一个任务,结束就可以继续执行
// CompletableFuture<Object> future4_5 = CompletableFuture.anyOf(future1, future2, future3);
// System.out.println(Thread.currentThread().getName()+":当前线程");
// future4_5.get();//等待所有任务完成 可以打印
// System.out.println(future4_5.get());
}
/**
* 本方法需要异步编排处理
* 1 2 没关系 查谁都行
* 3 4 5 必须依赖 1(1 -> 3、4、5)
* 3 4 5 是并列的,得等 1 完成
* 2 又和 1 没关系
*/
public void item(Long skuId) throws ExecutionException, InterruptedException {
//要返回给前端的大对象
SkuItemVo skuItemVo = new SkuItemVo();
CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> {
//1 sku基本信息获取 pms_sku_info
SkuInfoEntity info = getById(skuId);
skuItemVo.setInfo(info);
return info;
}, executor);
CompletableFuture<Void> saleAttrFuture = infoFuture.thenAcceptAsync((result) -> {
//3 spu的销售属性组合
Long spuId = result.getSpuId();
List<SkuItemSaleAttrVo> saleAttrVos = skuSaleAttrValueService.getSaleAttrBySpuId(spuId);
skuItemVo.setSaleAttr(saleAttrVos);
}, executor);
CompletableFuture<Void> descFuture = infoFuture.thenAcceptAsync((result) -> {
//4 spu的介绍 pms_spu_info_desc
Long spuId = result.getSpuId();
SpuInfoDescEntity desc = spuInfoDescService.getById(spuId);
skuItemVo.setDesc(desc);
}, executor);
CompletableFuture<Void> baseFuture = infoFuture.thenAcceptAsync((result) -> {
//5 spu的规格参数信息
Long spuId = result.getSpuId();
Long catalogId = result.getCatalogId();
List<SpuItemAttrGroupVo> attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(spuId, catalogId);
skuItemVo.setGroupAttrs(attrGroupVos);
}, executor);
CompletableFuture<Void> imagesFuture = CompletableFuture.runAsync(() -> {
//2 sku图片信息 pms_sku_images
List<SkuImagesEntity> images = skuImagesService.getImagesBySkuId(skuId);
skuItemVo.setImages(images);
}, executor);
CompletableFuture<Void> seckillFuture = CompletableFuture.runAsync(() -> {
//查询当前sku是否参加秒杀优惠
R r = seckillFeignService.getSkuSeckillInfo(skuId);
if (r.getCode() == 0) {
SeckillSkuInfoVo seckillSkuRedisVo = r.getData(new TypeReference<SeckillSkuInfoVo>() {
});
skuItemVo.setSeckillSkuInfoVo(seckillSkuRedisVo);
}
}, executor);
//异步编排 - 阻塞等结果
//等待所有1 2 3 4 5任务都完成 infoFuture可以省略
CompletableFuture.allOf(saleAttrFuture, descFuture, baseFuture, imagesFuture, seckillFuture).get();
return skuItemVo;
}
/**
* 两个任务组合
*/
public void fun3() throws ExecutionException, InterruptedException {
CompletableFuture<Object> future3_1 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务1开始。当前线程:" + Thread.currentThread().getId());
int i = 10 / 4;
System.out.println("任务1结束。结果运行:" + i);
return i;
}, executor);
CompletableFuture<Object> future3_2 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务2开始。当前线程:" + Thread.currentThread().getId());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务2结束...");
return "hello";
}, executor);
//runAfterBothAsync()不能感知前两步的执行结果 自己也没有返回值
future3_1.runAfterBothAsync(future3_2, ()->{
System.out.println("任务3开始。当前线程:" + Thread.currentThread().getId());
}, executor);
//thenAcceptBothAsync()能感知前两步的执行结果 自己没有返回值
future3_1.thenAcceptBothAsync(future3_2, (f1, f2)->{
System.out.println("任务3开始。之前的结果:f1=" + f1 + ";f2=" + f2);
}, executor);
//thenCombineAsync()能感知前两步的执行结果, 还能处理前面两个任务的返回值,并生成返回值 自己有返回值
CompletableFuture<String> future3_3 = future3_1.thenCombineAsync(future3_2, (f1, f2) -> {
return f1 + ": " + f2 + "->ww";
}, executor);
System.out.println(future3_3.get());
/**
* 两个任务 只要有一个完成就行 就能执行第三个任务 A || B = C
*/
//runAfterEitherAsync() 不感知前面任务的结果,自己也没有返回值
future3_1.runAfterEitherAsync(future3_2, () -> {
System.out.println("任务3开始执行。");
}, executor);
//acceptEitherAsync() 能感知前面任务的结果,自己没有返回值
future3_1.acceptEitherAsync(future3_2, (result) -> {//要求任务1、2的返回类型必须相同
System.out.println("任务3开始执行。" + result);
}, executor);
//applyToEitherAsync() 能感知前面任务的结果,自己有返回值
CompletableFuture<String> future3_4 = future3_1.applyToEitherAsync(future3_2, (result) -> {//要求任务1、2的返回类型必须相同
System.out.println("任务3开始执行。" + result);
return result.toString() + "哈哈";
}, executor);
System.out.println(future3_4.get());
}
}
线程池异步编排
最新推荐文章于 2024-07-29 14:22:26 发布