一，前置知识

1，用户线程和守护线程

1.所有用户线程执行完毕，程序就会退出，不再等待守护线程。

  1.     public static void main(String[] args) {
  2.       new Thread(()-> System.out.println("当前线程"+Thread.currentThread().getName()+"是"+(Thread.currentThread().isDaemon()?"守护线程":"用户线程"))).start();
  3.     }

2.用户线程不结束，程序就不会退出

  1. public class DemoA {
  3.     public static void main(String[] args) {
  4.         Thread thread = new Thread(DemoA::run,"线程1");
  5.         thread.start();
  6.     }
  8.     private static void run() {
  9.         System.out.println("当前线程" + Thread.currentThread().getName() + "是" + (Thread.currentThread().isDaemon() ? "守护线程" : "用户线程"));
  10.         while (true) ;
  11.     }
  12. }

3.不管守护线程结束没有，只要用户线程结束，程序就会退出

  1. public class DemoA {
  3.     public static void main(String[] args) {
  4.         Thread thread = new Thread(DemoA::run,"线程1");
  5.         //将线程1设置为守护线程
  6.         thread.setDaemon(true);
  7.         thread.start();
  8.     }
  10.     private static void run() {
  11.         System.out.println("当前线程" + Thread.currentThread().getName() + "是" + (Thread.currentThread().isDaemon() ? "守护线程" : "用户线程"));
  12.         while (true) ;
  13.     }
  14. }

2.回首FutureTask

1.FutureTask存在的问题

  1. public class Demob {
  3.     public static void main(String[] args)throws Exception {
  4.         FutureTask<String> futureTask = new FutureTask<>(Demob::call);
  5.         new Thread(futureTask,"t1").start();
  6.         //异步结果集的展现 ---- 会阻塞
  7.         //System.out.println(futureTask.get());
  8.         //轮询的方式去问 --- 消耗cpu资源
  9.         while (true) {
  10.             if (futureTask.isDone()){
  11.                 System.out.println(futureTask.get());
  12.                 break;
  13.             }
  14.         }
  16.         System.out.println("main结束");
  17.     }
  19.     private static String call() {
  20.         try {
  21.             TimeUnit.SECONDS.sleep(1);
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         }
  25.         return "yhd";
  26.     }
  27. }

从上面的代码可以看出FutureTask存在的问题：

  1. get()异步结果集的展现 —— 会阻塞
  2. futureTask.isDone()轮询的方式去问 —- 消耗cpu资源

2.想完成一些复杂的任务

  1. 应对Future的完成时间，完成了可以告诉我，也就是我们的回调通知。
  2. 将两个异步计算合成一个异步计算，这两个异步计算互相独立，同时第二个又依赖第一个的结果。
  3. 当Future集合中某个任务最快结束时，返回结果。
  4. 等待Future集合中的所有任务都完成。

二，CompletableFuture

1.介绍

异步函数式编程，Future接口的扩展与增强版。

可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。

  1. 完成通知回调
  2. 类似Linux管道符的形式，可以异步的计算，上一个计算结果可以给下一个，结合lambda表达式和函数式编程串起来转换和组合获得结果。

image.png

2.实例化

如果不指定线程池，默认所有的线程都是守护线程。

  1. public class DemoC {
  3.     private static ThreadPoolExecutor pool=new ThreadPoolExecutor(1,5,1, TimeUnit.SECONDS,new ArrayBlockingQueue<>(1));
  5.     public static void main(String[] args) throws Exception{
  6.         //创建一个有返回结果的实例
  7.         CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> "yhd", pool);
  8.         //创建一个没有返回结果的实例
  9.         CompletableFuture<Void> runAsync = CompletableFuture.runAsync(System.out::println);
  10.         pool.shutdown();
  11.     }
  12. }

3.异步+回调

whenComplete 和 join 的区别：

一个是执行完返回结果，一个是主动获取结果。

whenComplete：是执行当前任务的线程执行继续执行 whenComplete 的任务。
whenCompleteAsync：是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行。
方法不以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其他线程执行（如果是使用相同的线程池，也可能会被同一个线程选中执行）

  1. public class DemoC {
  3.     private static ThreadPoolExecutor pool=new ThreadPoolExecutor(1,5,1, TimeUnit.SECONDS,new ArrayBlockingQueue<>(1));
  5.     public static void main(String[] args) throws Exception{
  6.         //创建一个有返回结果的实例  计算完成时回调   发生异常时执行
  7.         CompletableFuture.supplyAsync(() -> "yhd", pool).whenComplete(DemoC::accept).exceptionally(Throwable::toString);
  8.         pool.shutdown();
  9.     }
  11.     private static void accept(String result, Throwable e) {
  12.         System.out.println(result);
  13.     }
  14. }

4.结果处理

handle 是执行任务完成时对结果的处理。
handle 是在任务完成后再执行，还可以处理异常的任务。

  1. /**
  2.  * @author yhd
  3.  * @createtime 2020/11/15 23:10
  4.  */
  5. public class DemoB {
  7.     public static void main(String[] args) {
  8.         CompletableFuture.supplyAsync(()->"尹会东").handle(DemoB::apply).whenCompleteAsync(((s, throwable) -> System.out.println(s)));
  9.     }
  11.     private static String apply(String s, Throwable throwable) {
  12.         if (null != throwable)
  13.             return throwable.getMessage();
  14.         return s + " 牛逼！";
  15.     }
  16. }

5.线程串行化

thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。
thenAccept方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。
thenRun方法：只要上面的任务执行完成，就开始执行thenRun，只是处理完任务后，执行 thenRun的后续操作
带有Async默认是异步执行的。这里所谓的异步指的是不在当前线程内执行。

  1. public class DemoE {
  3.     public static void main(String[] args) {
  4.         CompletableFuture<Integer> thenApply = CompletableFuture.supplyAsync(() -> 1).thenApply(integer -> 1);
  5.         CompletableFuture<Void> thenAccept = CompletableFuture.supplyAsync(() -> 1).thenAccept(System.out::println);
  6.         CompletableFuture<Void> thenRun = CompletableFuture.supplyAsync(() -> 1).thenRun(System.out::println);
  7.         System.out.println(thenApply.join());
  8.     }
  9. }

6.任务组合

1.两任务组合 - 都要完成

两个任务必须都完成，触发该任务。

thenCombine：组合两个future，获取两个future任务的返回结果，并返回当前任务的返回值
thenAcceptBoth：组合两个future，获取两个future任务的返回结果，然后处理任务，没有返回值。
runAfterBoth：组合两个future，不需要获取future的结果，只需两个future处理完任务后，处理该任务。

  1. public class DemoF {
  3.     public static void main(String[] args) {
  4.         CompletableFuture
  5.                 .supplyAsync(() -> "hello")
  6.                 .thenApplyAsync(t -> t + " world!")
  7.                 .thenCombineAsync(
  8.                         CompletableFuture
  9.                                 .completedFuture(" CompletableFuture"), (t, u) -> t + u)
  10.                 .whenComplete(DemoF::accept);
  11.     }
  13.     private static void accept(String t, Throwable u) {
  14.         System.out.println(t);
  15.     }
  16. }

2.两任务组合 - 一个完成

当两个任务中，任意一个future任务完成的时候，执行任务。
applyToEither：两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值。
acceptEither：两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
runAfterEither：两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值

3.多任务组合

allOf：等待所有任务完成
anyOf：只要有一个任务完成

7.计算接口性能

1.一淘

  1. /**
  2.  * @author yhd
  3.  * @createtime 2020/11/15 15:11
  4.  * 查询多个电商网站同一个商品的价格
  5.  * 同步和异步两种方式
  6.  */
  7. public class DemoD {
  9.     static List<Gmall> gmalls= Arrays.asList(
  10.                 new Gmall("京东"),
  11.                 new Gmall("拼多多"),
  12.                 new Gmall("淘宝"),
  13.                 new Gmall("唯品会"),
  14.                 new Gmall("分期乐"));
  17.     /**
  18.      * 同步
  19.      * @param gmalls
  20.      * @param productName
  21.      * @return
  22.      */
  23.     public static List<String> getPriceSync(List<Gmall> gmalls,String productName){
  24.        return  gmalls.stream().map(gmall->String.format(productName+"in %s price is %d ",gmall.getGmallName(),gmall.getPriceByProductName(productName))).collect(Collectors.toList());
  25.     }
  27.     /**
  28.      * 异步
  29.      * @param gmalls
  30.      * @param productName
  31.      * @return
  32.      */
  33.     public static List<String> getPriceAsync(List<Gmall> gmalls,String productName){
  34.         return gmalls.stream().map(gmall->CompletableFuture.supplyAsync(()->String.format(productName+"in %s price is %d ",gmall.getGmallName(),gmall.getPriceByProductName(productName)))).collect(Collectors.toList()).stream().map(CompletableFuture::join).collect(Collectors.toList());
  35.     }
  37.     public static void main(String[] args) {
  39.         long startTime = System.currentTimeMillis();
  40.         getPriceSync(gmalls,"金鳞岂是池中物").forEach(System.out::println);
  41.         long endTime = System.currentTimeMillis();
  42.         System.out.println("同步"+ (endTime-startTime));
  44.         System.out.println("------------------------");
  46.         long s = System.currentTimeMillis();
  47.         getPriceAsync(gmalls,"金鳞岂是池中物").forEach(System.out::println);
  48.         long e = System.currentTimeMillis();
  49.         System.out.println("异步"+ (e-s));
  50.     }
  51. }
  52. @Data
  53. @NoArgsConstructor
  54. @AllArgsConstructor
  55. class Gmall{
  56.     private String gmallName;
  58.     public Integer getPriceByProductName(String productName){
  59.         try {
  60.             TimeUnit.SECONDS.sleep(1);
  61.         } catch (InterruptedException e) {
  62.             e.printStackTrace();
  63.         }
  64.         return (int)(Math.random()*100)+1;
  65.     }
  66. }

结果：

  1. =================================
  2. 金鳞岂是池中物in 京东 price is 100 
  3. 金鳞岂是池中物in 拼多多 price is 12 
  4. 金鳞岂是池中物in 淘宝 price is 25 
  5. 金鳞岂是池中物in 唯品会 price is 35 
  6. 金鳞岂是池中物in 分期乐 price is 60 
  7. 同步5081
  8. ------------------------
  9. 金鳞岂是池中物in 京东 price is 57 
  10. 金鳞岂是池中物in 拼多多 price is 68 
  11. 金鳞岂是池中物in 淘宝 price is 84 
  12. 金鳞岂是池中物in 唯品会 price is 16 
  13. 金鳞岂是池中物in 分期乐 price is 20 
  14. 异步1387
  15. =================================

2.检索

  1. /**
  2.  * @author yhd
  3.  * @createtime 2020/11/15 23:40
  4.  */
  5. public class DemoC {
  7.     //模拟数据库
  8.     private static Map<String,Company> db=new HashMap<>();
  9.     //模拟查询条件
  10.     private static List<String> persons;
  11.     //初始化数据
  12.     static {
  13.         persons=Arrays.asList("马云","马化腾","李彦宏","张朝阳","刘强东","王兴");
  14.         db.put("马云",new Company("马云","阿里巴巴"));
  15.         db.put("马化腾",new Company("马化腾","腾讯"));
  16.         db.put("李彦宏",new Company("李彦宏","百度"));
  17.         db.put("张朝阳",new Company("张朝阳","搜狐"));
  18.         db.put("刘强东",new Company("刘强东","京东"));
  19.         db.put("王兴",new Company("王兴","美团"));
  20.     }
  21.     //模拟去数据库查询
  22.     public static Company selectDB(String key){
  23.         try {
  24.             TimeUnit.SECONDS.sleep(1);
  25.         } catch (InterruptedException e) {
  26.             e.printStackTrace();
  27.         }
  28.         return db.get(key);
  29.     }
  32.     public static void main(String[] args) {
  33.         Sync();
  34.         System.out.println();
  35.         Async();
  36.         System.out.println();
  37.         System.out.println(result());
  38.     }
  39.     //同步查询
  40.     public static void Sync(){
  41.         Long startTime=System.currentTimeMillis();
  42.         persons.stream().map(key->selectDB(key).getWorks()).collect(Collectors.toList()).forEach(System.out::println);
  43.         Long endTime=System.currentTimeMillis();
  44.         System.out.println(endTime-startTime);
  45.     }
  46.     //异步查询
  47.     public static void Async(){
  48.         Long startTime=System.currentTimeMillis();
  49.         persons.stream().map(key->CompletableFuture.supplyAsync(()->selectDB(key).getWorks())).collect(Collectors.toList()).stream().map(CompletableFuture::join).collect(Collectors.toList()).forEach(System.out::println);
  50.         Long endTime=System.currentTimeMillis();
  51.         System.out.println(endTime-startTime);
  52.     }
  53.     //转换成map返回
  54.     public static Map<String,String> result(){
  55.         return persons.stream().map(key -> CompletableFuture.supplyAsync(() -> selectDB(key))).collect(Collectors.toList()).stream().map(CompletableFuture::join).collect(Collectors.toMap(Company::getPerson,Company::getWorks));
  56.     }
  58. }
  59. @Data
  60. @NoArgsConstructor
  61. @AllArgsConstructor
  62. class Company{
  63.     private String person;
  65.     private String works;
  66. }

结果

  1. 阿里巴巴
  2. 腾讯
  3. 百度
  4. 搜狐
  5. 京东
  6. 美团
  7. 6053
  9. 阿里巴巴
  10. 腾讯
  11. 百度
  12. 搜狐
  13. 京东
  14. 美团
  15. 1406
  17. {张朝阳=搜狐, 马云=阿里巴巴, 王兴=美团, 李彦宏=百度, 刘强东=京东, 马化腾=腾讯}

3.商品详情

  2. /**
  3.  * @author 二十
  4.  * @since 2021/8/28 7:54 下午
  5.  */
  6. public class CompletableFutureTest {
  8.     private static ThreadPoolExecutor pool = new ThreadPoolExecutor(1, 5, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1));
  10.     public static void main(String[] args) {
  11.         Map<String, Result> result = new HashMap<>(4);
  13.         Long s = System.currentTimeMillis();
  14.         CompletableFuture<Result> skuInfoFuture = CompletableFuture.supplyAsync(() -> {
  15.             Result skuInfo = getSkuInfo(1);
  16.             result.put(skuInfo.getName(), skuInfo);
  17.             return skuInfo;
  18.         }, pool);
  19.         CompletableFuture<Void> skuPriceFuture = CompletableFuture.runAsync(() -> {
  20.             Result skuPrice = getSkuPrice(1);
  21.             result.put(skuPrice.getName(), skuPrice);
  22.         }, pool);
  23.         CompletableFuture<Void> skuImgsFuture = skuInfoFuture.thenAcceptAsync(r -> {
  24.             Result skuImgs = getSkuImgs(r.getId());
  25.             result.put(skuImgs.getName(), skuImgs);
  27.         }, pool);
  28.         CompletableFuture<Void> spuInfoFuture = skuInfoFuture.thenAcceptAsync(r -> {
  29.             Result spuInfo = getSpuInfo(r.getId());
  30.             result.put(spuInfo.getName(), spuInfo);
  32.         }, pool);
  33.         CompletableFuture.allOf(skuInfoFuture, skuPriceFuture, skuImgsFuture, spuInfoFuture).join();
  34.         System.out.println(result);
  35.         Long e = System.currentTimeMillis();
  36.         System.out.println("查詢總計耗時：" + (e - s));
  37.         pool.shutdown();
  38.     }
  40.     /**
  41.      * 查询sku基本信息
  42.      */
  43.     public static Result getSkuInfo(Integer key) {
  44.         sleep();
  45.         return new Result(1, "skuInfo");
  46.     }
  48.     /**
  49.      * 查询sku图片信息
  50.      */
  51.     public static Result getSkuImgs(Integer key) {
  52.         sleep();
  53.         return new Result(1, "skuImgs");
  54.     }
  56.     /**
  57.      * 查询spu销售属性
  58.      */
  59.     public static Result getSpuInfo(Integer key) {
  60.         sleep();
  61.         return new Result(1, "spuInfo");
  62.     }
  64.     /**
  65.      * 查询sku价格
  66.      */
  67.     public static Result getSkuPrice(Integer key) {
  68.         sleep();
  69.         return new Result(1, "skuPrice");
  70.     }
  72.     public static void sleep() {
  73.         try {
  74.             TimeUnit.SECONDS.sleep(2);
  75.         } catch (InterruptedException e) {
  76.             e.printStackTrace();
  77.         }
  78.     }
  81.     @Data
  82.     @NoArgsConstructor
  83.     @AllArgsConstructor
  84.     private static class Result {
  85.         private Integer id;
  87.         private String name;
  88.     }
  89. }

夜拍.jpeg
哪有什么岁月静好，不过是在你看不见的地方负重前行。