当前位置： 首页 > news >正文

食品网站建设风格内容营销成功案例

news 2025/7/13 1:51:59
食品网站建设风格,内容营销成功案例,建设网站团队,洛阳做家教去什么网站CompletableFuture使用详解 简介 概述 CompletableFuture是对Future的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富的扩展，完美弥补了Future的局限性，同时CompletableFuture实现了对任务编排的能力。借助这项能力…

CompletableFuture使用详解

简介

概述

  • CompletableFuture是对Future的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富的扩展，完美弥补了Future的局限性，同时CompletableFuture实现了对任务编排的能力。借助这项能力，可以轻松地组织不同任务的运行顺序、规则以及方式。从某种程度上说，这项能力是它的核心能力。而在以往，虽然通过CountDownLatch等工具类也可以实现任务的编排，但需要复杂的逻辑处理，不仅耗费精力且难以维护。

  • CompletableFuture的继承结构如下：

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a61HTSe5-1680694141534)(C:%5CUsers%5Cquyanliang%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1680692539301.png)]

  • CompletionStage接口定义了任务编排的方法，执行某一阶段，可以向下执行后续阶段。异步执行的，默认线程池是ForkJoinPool.commonPool()，但为了业务之间互不影响，且便于定位问题，强烈推荐使用自定义线程池。

  • CompletableFuture中默认线程池如下：

  • // 根据commonPool的并行度来选择,而并行度的计算是在ForkJoinPool的静态代码段完成的
private static final boolean useCommonPool =(ForkJoinPool.getCommonPoolParallelism() > 1);private static final Executor asyncPool = useCommonPool ?ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

  • ForkJoinPool中初始化commonPool的参数 \

  • static {// initialize field offsets for CAS etctry {U = sun.misc.Unsafe.getUnsafe();Class<?> k = ForkJoinPool.class;CTL = U.objectFieldOffset(k.getDeclaredField("ctl"));RUNSTATE = U.objectFieldOffset(k.getDeclaredField("runState"));STEALCOUNTER = U.objectFieldOffset(k.getDeclaredField("stealCounter"));Class<?> tk = Thread.class;……} catch (Exception e) {throw new Error(e);}commonMaxSpares = DEFAULT_COMMON_MAX_SPARES;defaultForkJoinWorkerThreadFactory =new DefaultForkJoinWorkerThreadFactory();modifyThreadPermission = new RuntimePermission("modifyThread");// 调用makeCommonPool方法创建commonPool,其中并行度为逻辑核数-1common = java.security.AccessController.doPrivileged(new java.security.PrivilegedAction<ForkJoinPool>() {public ForkJoinPool run() { return makeCommonPool(); }});int par = common.config & SMASK; // report 1 even if threads disabledcommonParallelism = par > 0 ? par : 1;
}

功能

常用方法

  • 依赖关系

    • thenApply()：把前面任务的执行结果，交给后面的Function
    • thenCompose()：用来连接两个有依赖关系的任务，结果由第二个任务返回
  • and集合关系
    • thenCombine()：合并任务，有返回值
    • thenAccepetBoth()：两个任务执行完成后，将结果交给thenAccepetBoth处理，无返回值
    • runAfterBoth()：两个任务都执行完成后，执行下一步操作(Runnable类型任务)
    or聚合关系
    • applyToEither()：两个任务哪个执行的快，就使用哪一个结果，有返回值
    • acceptEither()：两个任务哪个执行的快，就消费哪一个结果，无返回值
    • runAfterEither()：任意一个任务执行完成，进行下一步操作(Runnable类型任务)
  • 并行执行
    • allOf()：当所有给定的 CompletableFuture 完成时，返回一个新的 CompletableFuture
    • anyOf()：当任何一个给定的CompletablFuture完成时，返回一个新的CompletableFuture
  • 结果处理
    • whenComplete：当任务完成时，将使用结果(或 null)和此阶段的异常(或 null如果没有)执行给定操作
    • exceptionally：返回一个新的CompletableFuture，当前面的CompletableFuture完成时，它也完成，当它异常完成时，给定函数的异常触发这个CompletableFuture的完成

异步操作

应用场景

结果转换

  • 将上一段任务的执行结果作为下一阶段任务的入参参与重新计算，产生新的结果。

thenApply

  • thenApply接收一个函数作为参数，使用该函数处理上一个CompletableFuture调用的结果，并返回一个具有处理结果的Future对象。

  • 常用使用：

  • public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)

  • 具体使用：

  • CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {int result = 100;System.out.println("第一次运算：" + result);return result;
}).thenApply(number -> {int result = number * 3;System.out.println("第二次运算：" + result);return result;
});

thenCompose

  • thenCompose的参数为一个返回CompletableFuture实例的函数，该函数的参数是先前计算步骤的结果。

  • 常用方法：

  • public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn);
public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn) ;

  • 具体使用：

  • CompletableFuture<Integer> future = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(30);System.out.println("第一次运算：" + number);return number;}}).thenCompose(new Function<Integer, CompletionStage<Integer>>() {@Overridepublic CompletionStage<Integer> apply(Integer param) {return CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = param * 2;System.out.println("第二次运算：" + number);return number;}});}});

thenApply 和 thenCompose的区别：

  • thenApply转换的是泛型中的类型，返回的是同一个CompletableFuture；
  • thenCompose将内部的CompletableFuture调用展开来并使用上一个CompletableFutre调用的结果在下一步的CompletableFuture调用中进行运算，是生成一个新的CompletableFuture。

结果消费

  • 与结果处理和结果转换系列函数返回一个新的CompletableFuture不同，结果消费系列函数只对结果执行Action，而不返回新的计算值。
  • 根据对结果的处理方式，结果消费函数又可以分为下面三大类：
    • thenAccept()：对单个结果进行消费
    • thenAcceptBoth()：对两个结果进行消费
    • thenRun()：不关心结果，只对结果执行Action

thenAccept

  • 观察该系列函数的参数类型可知，它们是函数式接口Consumer，这个接口只有输入，没有返回值。

  • 常用方法：

  • public CompletionStage<Void> thenAccept(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);

  • 具体使用：

  • CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {int number = new Random().nextInt(10);System.out.println("第一次运算：" + number);return number;}).thenAccept(number ->System.out.println("第二次运算：" + number * 5));

thenAcceptBoth

  • thenAcceptBoth函数的作用是，当两个CompletionStage都正常完成计算的时候，就会执行提供的action消费两个异步的结果。

  • 常用方法：

  • public <U> CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);

  • 具体使用：

  • CompletableFuture<Integer> futrue1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(3) + 1;try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("任务1结果：" + number);return number;}
});CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(3) + 1;try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("任务2结果：" + number);return number;}
});futrue1.thenAcceptBoth(future2, new BiConsumer<Integer, Integer>() {@Overridepublic void accept(Integer x, Integer y) {System.out.println("最终结果：" + (x + y));}
});

thenRun

  • thenRun也是对线程任务结果的一种消费函数，与thenAccept不同的是，thenRun会在上一阶段 CompletableFuture计算完成的时候执行一个Runnable，而Runnable并不使用该CompletableFuture计算的结果。

  • 常用方法：

  • public CompletionStage<Void> thenRun(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action);

  • 具体使用：

  • CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {int number = new Random().nextInt(10);System.out.println("第一阶段：" + number);return number;
}).thenRun(() ->System.out.println("thenRun 执行"));

结果组合

thenCombine

  • 合并两个线程任务的结果，并进一步处理。

  • 常用方法：

  • public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn, Executor executor);

  • 具体使用：

  • CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(10);System.out.println("任务1结果：" + number);return number;}});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(10);System.out.println("任务2结果：" + number);return number;}});
CompletableFuture<Integer> result = future1.thenCombine(future2, new BiFunction<Integer, Integer, Integer>() {@Overridepublic Integer apply(Integer x, Integer y) {return x + y;}});
System.out.println("组合后结果：" + result.get());

任务交互

  • 线程交互指将两个线程任务获取结果的速度相比较，按一定的规则进行下一步处理。

applyToEither

  • 两个线程任务相比较，先获得执行结果的，就对该结果进行下一步的转化操作。

  • 常用方法：

  • public <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn);

  • 具体使用：

  • CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(10);try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("任务1结果:" + number);return number;}});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(10);try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("任务2结果:" + number);return number;}
});future1.applyToEither(future2, new Function<Integer, Integer>() {@Overridepublic Integer apply(Integer number) {System.out.println("最快结果：" + number);return number * 2;}
});

acceptEither

  • 两个线程任务相比较，先获得执行结果的，就对该结果进行下一步的消费操作。

  • 常用方法：

  • public CompletionStage<Void> acceptEither(CompletionStage<? extends T> other,Consumer<? super T> action);
public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action);

  • 具体使用：

  • CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(10) + 1;try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("第一阶段：" + number);return number;}
});CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(10) + 1;try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("第二阶段：" + number);return number;}
});future1.acceptEither(future2, new Consumer<Integer>() {@Overridepublic void accept(Integer number) {System.out.println("最快结果：" + number);}
});

runAfterEither

  • 两个线程任务相比较，有任何一个执行完成，就进行下一步操作，不关心运行结果。

  • 常用方法：

  • public CompletionStage<Void> runAfterEither(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action);

  • 具体使用：

  • CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(5);try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("任务1结果：" + number);return number;}
});CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {@Overridepublic Integer get() {int number = new Random().nextInt(5);try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("任务2结果:" + number);return number;}
});future1.runAfterEither(future2, new Runnable() {@Overridepublic void run() {System.out.println("已经有一个任务完成了");}
}).join();

anyOf

  • anyOf() 的参数是多个给定的 CompletableFuture，当其中的任何一个完成时，方法返回这个 CompletableFuture。

  • 常用方法：

  • public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

  • 具体使用：

  • Random random = new Random();
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {try {TimeUnit.SECONDS.sleep(random.nextInt(5));} catch (InterruptedException e) {e.printStackTrace();}return "hello";
});CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {try {TimeUnit.SECONDS.sleep(random.nextInt(1));} catch (InterruptedException e) {e.printStackTrace();}return "world";
});
CompletableFuture<Object> result = CompletableFuture.anyOf(future1, future2);

allOf

  • allOf方法用来实现多 CompletableFuture 的同时返回。

  • 常用方法：

  • public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)

  • 具体使用：

  • CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("future1完成！");return "future1完成！";
});CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {System.out.println("future2完成！");return "future2完成！";
});CompletableFuture<Void> combindFuture = CompletableFuture.allOf(future1, future2);try {combindFuture.get();
} catch (InterruptedException e) {e.printStackTrace();
} catch (ExecutionException e) {e.printStackTrace();
}

  • CompletableFuture常用方法总结:

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1mWmBu8C-1680694141535)(C:%5CUsers%5Cquyanliang%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1680693984873.png)]

  • 注：CompletableFuture中还有很多功能丰富的方法，这里就不一一列举。

使用案例

实现最优的“烧水泡茶”程序

  • 著名数学家华罗庚先生在《统筹方法》这篇文章里介绍了一个烧水泡茶的例子，文中提到最优的工序应该是下面这样：

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VW2F4P5T-1680694141536)(C:%5CUsers%5Cquyanliang%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1680694045463.png)]

  • 对于烧水泡茶这个程序，一种最优的分工方案：用两个线程 T1 和 T2 来完成烧水泡茶程序，T1 负责洗水壶、烧开水、泡茶这三道工序，T2 负责洗茶壶、洗茶杯、拿茶叶三道工序，其中 T1 在执行泡茶这道工序时需要等待 T2 完成拿茶叶的工序。

基于Future实现

  • public class FutureTaskTest{public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建任务T2的FutureTaskFutureTask<String> ft2 = new FutureTask<>(new T2Task());// 创建任务T1的FutureTaskFutureTask<String> ft1 = new FutureTask<>(new T1Task(ft2));// 线程T1执行任务ft2Thread T1 = new Thread(ft2);T1.start();// 线程T2执行任务ft1Thread T2 = new Thread(ft1);T2.start();// 等待线程T1执行结果System.out.println(ft1.get());}
}// T1Task需要执行的任务：
// 洗水壶、烧开水、泡茶
class T1Task implements Callable<String> {FutureTask<String> ft2;// T1任务需要T2任务的FutureTaskT1Task(FutureTask<String> ft2){this.ft2 = ft2;}@Overridepublic String call() throws Exception {System.out.println("T1:洗水壶...");TimeUnit.SECONDS.sleep(1);System.out.println("T1:烧开水...");TimeUnit.SECONDS.sleep(15);// 获取T2线程的茶叶String tf = ft2.get();System.out.println("T1:拿到茶叶:"+tf);System.out.println("T1:泡茶...");return "上茶:" + tf;}
}
// T2Task需要执行的任务:
// 洗茶壶、洗茶杯、拿茶叶
class T2Task implements Callable<String> {@Overridepublic String call() throws Exception {System.out.println("T2:洗茶壶...");TimeUnit.SECONDS.sleep(1);System.out.println("T2:洗茶杯...");TimeUnit.SECONDS.sleep(2);System.out.println("T2:拿茶叶...");TimeUnit.SECONDS.sleep(1);return "龙井";}
}

基于CompletableFuture实现

  • public class CompletableFutureTest {public static void main(String[] args) {//任务1：洗水壶->烧开水CompletableFuture<Void> f1 = CompletableFuture.runAsync(() -> {System.out.println("T1:洗水壶...");sleep(1, TimeUnit.SECONDS);System.out.println("T1:烧开水...");sleep(15, TimeUnit.SECONDS);});//任务2：洗茶壶->洗茶杯->拿茶叶CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> {System.out.println("T2:洗茶壶...");sleep(1, TimeUnit.SECONDS);System.out.println("T2:洗茶杯...");sleep(2, TimeUnit.SECONDS);System.out.println("T2:拿茶叶...");sleep(1, TimeUnit.SECONDS);return "龙井";});//任务3：任务1和任务2完成后执行：泡茶CompletableFuture<String> f3 = f1.thenCombine(f2, (__, tf) -> {System.out.println("T1:拿到茶叶:" + tf);System.out.println("T1:泡茶...");return "上茶:" + tf;});//等待任务3执行结果System.out.println(f3.join());}static void sleep(int t, TimeUnit u){try {u.sleep(t);} catch (InterruptedException e) {}}
}
http://www.tj-hxxt.cn/news/27700.html

相关文章：

  • 做网站的软件page网页搜索
  • 罗湖网站建设设计东莞网络优化哪家公司好
  • 南昌网站建设公司渠道免费产品推广网站
  • 网站制作方案去哪找sem搜索引擎
  • 河北平台网站建设价位公司地址怎么弄在百度上显示
  • 六合哪家做网站建设千度seo
  • 做css网站培训李守洪
  • 鲜花网站设计百度快速排名提升
  • 大连做网站比较好的公司seo网络营销公司
  • 自己怎么做淘宝网站宣传软文是什么意思
  • 教你免费申请个人平台二十个优化
  • eclipse sdk做网站百度一下百度首页官网
  • 后端开发和前端开发的区别百度seo招聘
  • 闵行网站建设外包什么是seo标题优化
  • 招远建网站求老哥给几个靠谱的网站
  • 视频号小店怎么样优化网站seo
  • 外链seo推广关键词优化师
  • 网站负责人核验现场拍摄照片推蛙网络
  • 网站建设 无锡如何优化企业网站
  • 网站keywords多少字网站运营培训
  • 网站内容页面怎么做抖音视频排名优化
  • 上海做外贸网站网络营销平台推广方案
  • 网站后台的seo功能二级域名网站查询入口
  • 郑州网站建设的公司网站及搜索引擎优化建议
  • 个人网页的代码页面seo优化
  • 嘉兴做网站公司企业网络营销案例
  • 上传网站源码网站友情链接连接
  • 服装工厂做网站的好处黑帽seo排名优化
  • 高明网站建设首选公司唐山百度seo公司
  • 上海知名网站建设公司百度百科入口