重庆博建设计院公司是网站设计工作室网站源码

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

重庆博建设计院公司是网站,设计工作室网站源码,射阳县住房和城乡建设局网站,新闻门户网站是什么1. CallableFutureFutureTask介绍 直接继承Thread或者实现Runnable接口都可以创建线程#xff0c;但是这两种方法都有一个问题就是#xff1a;没有返回值#xff0c;也就是不能获取执行完的结果。因此java1.5就提供了Callable接口来实现这一场景#xff0c;而Fu…1. CallableFutureFutureTask介绍 直接继承Thread或者实现Runnable接口都可以创建线程但是这两种方法都有一个问题就是没有返回值也就是不能获取执行完的结果。因此java1.5就提供了Callable接口来实现这一场景而Future和FutureTask就可以和Callable接口配合起来使用。 FunctionalInterface public interface Runnable {public abstract void run(); } FunctionalInterface public interface CallableV {V call() throws Exception; } Runnable 的缺陷 不能返回一个返回值不能抛出 checked Exception Callable的call方法可以有返回值可以声明抛出异常。和 Callable 配合的有一个 Future 类通过 Future 可以了解任务执行情况或者取消任务的执行还可获取任务执行的结果这些功能都是 Runnable 做不到的Callable 的功能要比 Runnable 强大。 new Thread(new Runnable() {Overridepublic void run() {System.out.println(通过Runnable方式执行任务);} }).start();FutureTask task new FutureTask(new Callable() {Overridepublic Object call() throws Exception {System.out.println(通过Callable方式执行任务);Thread.sleep(3000);return 返回任务结果;} }); new Thread(task).start(); System.out.println(task.get()); 1.1 Future 的API Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果该方法会阻塞直到任务返回结果。 boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行或者等等任务结束boolean isCancelled () 任务是否已经取消任务正常完成前将其取消则返回 trueboolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消都将返回trueV get () throws InterruptedException, ExecutionException 等待任务执行结束然后获得V类型的结果。InterruptedException 线程被中断异常 ExecutionException任务执行异常如果任务被取消还会抛出CancellationExceptionV get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样多了设置超时时间。参数timeout指定超时时间uint指定时间的单位在枚举类TimeUnit中有相关的定义。如果计算超时将抛出TimeoutException 1.2 FutureTask 使用 Future实际采用FutureTask实现该对象相当于是消费者和生产者的桥梁消费者通过 FutureTask 存储任务的处理结果更新任务的状态未开始、正在处理、已完成等。而生产者拿到的 FutureTask 被转型为 Future 接口可以阻塞式获取任务的处理结果非阻塞式获取任务处理状态。 FutureTask既可以被当做Runnable来执行也可以被当做Future来获取Callable的返回结果。 把 Callable 实例当作 FutureTask 构造函数的参数生成 FutureTask 的对象然后把这个对象当作一个 Runnable 对象放到线程池中或另起线程去执行最后还可以通过 FutureTask 获取任务执行的结果。 public class FutureTaskDemo {public static void main(String[] args) throws ExecutionException, InterruptedException {Task task new Task();//构建futureTaskFutureTaskInteger futureTask new FutureTask(task);//作为Runnable入参new Thread(futureTask).start();System.out.println(task运行结果futureTask.get());}static class Task implements CallableInteger {Overridepublic Integer call() throws Exception {System.out.println(子线程正在计算);int sum 0;for (int i 0; i 100; i) {sum i;}return sum;}} } 使用案例促销活动中商品信息查询 在维护促销活动时需要查询商品信息包括商品基本信息、商品价格、商品库存、商品图片、商品销售状态等。这些信息分布在不同的业务中心由不同的系统提供服务。如果采用同步方式假设一个接口需要50ms那么一个商品查询下来就需要200ms-300ms这对于我们来说是不满意的。如果使用Future改造则需要的就是最长耗时服务的接口也就是50ms左右。 public class FutureTaskDemo2 {public static void main(String[] args) throws ExecutionException, InterruptedException {FutureTaskString ft1 new FutureTask(new T1Task());FutureTaskString ft2 new FutureTask(new T2Task());FutureTaskString ft3 new FutureTask(new T3Task());FutureTaskString ft4 new FutureTask(new T4Task());FutureTaskString ft5 new FutureTask(new T5Task());//构建线程池ExecutorService executorService Executors.newFixedThreadPool(5);executorService.submit(ft1);executorService.submit(ft2);executorService.submit(ft3);executorService.submit(ft4);executorService.submit(ft5);//获取执行结果System.out.println(ft1.get());System.out.println(ft2.get());System.out.println(ft3.get());System.out.println(ft4.get());System.out.println(ft5.get());executorService.shutdown();}static class T1Task implements CallableString {Overridepublic String call() throws Exception {System.out.println(T1:查询商品基本信息…);TimeUnit.MILLISECONDS.sleep(50);return 商品基本信息查询成功;}}static class T2Task implements CallableString {Overridepublic String call() throws Exception {System.out.println(T2:查询商品价格…);TimeUnit.MILLISECONDS.sleep(50);return 商品价格查询成功;}}static class T3Task implements CallableString {Overridepublic String call() throws Exception {System.out.println(T3:查询商品库存…);TimeUnit.MILLISECONDS.sleep(50);return 商品库存查询成功;}}static class T4Task implements CallableString {Overridepublic String call() throws Exception {System.out.println(T4:查询商品图片…);TimeUnit.MILLISECONDS.sleep(50);return 商品图片查询成功;}}static class T5Task implements CallableString {Overridepublic String call() throws Exception {System.out.println(T5:查询商品销售状态…);TimeUnit.MILLISECONDS.sleep(50);return 商品销售状态查询成功;}}} 1.3 Future的局限性 从本质上说Future表示一个异步计算的结果。它提供了isDone()来检测计算是否已经完成并且在计算结束后可以通过get()方法来获取计算结果。在异步计算中Future确实是个非常优秀的接口。但是它的本身也确实存在着许多限制 并发执行多任务Future只提供了get()方法来获取结果并且是阻塞的。所以除了等待你别无他法无法对多个任务进行链式调用如果你希望在计算任务完成后执行特定动作比如发邮件但Future却没有提供这样的能力无法组合多个任务如果你运行了10个任务并期望在它们全部执行结束后执行特定动作那么在Future中这是无能为力的没有异常处理Future接口中没有关于异常处理的方法

1. CompletableFuture使用详解 简单的任务用Future获取结果还好但我们并行提交的多个异步任务往往并不是独立的很多时候业务逻辑处理存在串行[依赖]、并行、聚合的关系。如果要我们手动用 Future 实现是非常麻烦的。 CompletableFuture是Future接口的扩展和增强。CompletableFuture实现了Future接口并在此基础上进行了丰富地扩展完美地弥补了Future上述的种种问题。更为重要的是CompletableFuture实现了对任务的编排能力。借助这项能力我们可以轻松地组织不同任务的运行顺序、规则以及方式。从某种程度上说这项能力是它的核心能力。而在以往虽然通过CountDownLatch等工具类也可以实现任务的编排但需要复杂的逻辑处理不仅耗费精力且难以维护。 2.1 应用场景 描述依赖关系 thenApply() 把前面异步任务的结果交给后面的FunctionthenCompose()用来连接两个有依赖关系的任务结果由第二个任务返回 描述and聚合关系 thenCombine:任务合并有返回值thenAccepetBoth:两个任务执行完成后将结果交给thenAccepetBoth消耗无返回值。runAfterBoth:两个任务都执行完成后执行下一步操作Runnable。 描述or聚合关系 applyToEither:两个任务谁执行的快就使用那一个结果有返回值。acceptEither: 两个任务谁执行的快就消耗那一个结果无返回值。runAfterEither: 任意一个任务执行完成进行下一步操作(Runnable)。 并行执行 CompletableFuture类自己也提供了anyOf()和allOf()用于支持多个CompletableFuture并行执行 2.2 创建异步操作 CompletableFuture 提供了四个静态方法来创建一个异步操作 public static CompletableFutureVoid runAsync(Runnable runnable)public static CompletableFutureVoid runAsync(Runnable runnable, Executor executor)public static U CompletableFutureU supplyAsync(SupplierU supplier)public static U CompletableFutureU supplyAsync(SupplierU supplier, Executor executor)  这四个方法区别在于 runAsync 方法以Runnable函数式接口类型为参数没有返回结果supplyAsync 方法Supplier函数式接口类型为参数返回结果类型为USupplier 接口的 get() 方法是有返回值的会阻塞没有指定Executor的方法会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池则使用指定的线程池运行。默认情况下 CompletableFuture 会使用公共的 ForkJoinPool 线程池这个线程池默认创建的线程数是 CPU 的核数也可以通过 JVM option:-Djava.util.concurrent.ForkJoinPool.common.parallelism 来设置 ForkJoinPool 线程池的线程数。如果所有 CompletableFuture 共享一个线程池那么一旦有任务执行一些很慢的 I/O 操作就会导致线程池中所有线程都阻塞在 I/O 操作上从而造成线程饥饿进而影响整个系统的性能。所以强烈建议你要根据不同的业务类型创建不同的线程池以避免互相干扰 runAsyncsupplyAsync Runnable runnable () - System.out.println(执行无返回结果的异步任务);CompletableFuture.runAsync(runnable);CompletableFutureString future CompletableFuture.supplyAsync(() - {System.out.println(执行有返回值的异步任务);try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}return Hello World;});String result future.get();System.out.println(result); 执行无返回结果的异步任务 执行有返回值的异步任务 2.3 获取结果 joinget join()和get()方法都是用来获取CompletableFuture异步之后的返回值。join()方法抛出的是uncheck异常即未经检查的异常),不会强制开发者抛出。get()方法抛出的是经过检查的异常ExecutionException, InterruptedException 需要用户手动处理抛出或者 try catch 2.4 结果处理 当CompletableFuture的计算结果完成或者抛出异常的时候我们可以执行特定的 Action。主要是下面的方法 public CompletableFutureT whenComplete(BiConsumer? super T,? super Throwable action)public CompletableFutureT whenCompleteAsync(BiConsumer? super T,? super Throwable action)public CompletableFutureT whenCompleteAsync(BiConsumer? super T,? super Throwable action, Executor executor)public CompletableFutureT exceptionally(FunctionThrowable,? extends T fn) Action的类型是BiConsumer它可以处理正常的计算结果或者异常情况。方法不以Async结尾意味着Action使用相同的线程执行而Async可能会使用其它的线程去执行(如果使用相同的线程池也可能会被同一个线程选中执行)。这几个方法都会返回CompletableFuture当Action执行完毕后它的结果返回原始的CompletableFuture的计算结果或者返回异常 whenCompleteexceptionally CompletableFutureString future CompletableFuture.supplyAsync(() - {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}if (new Random().nextInt(10) % 2 0) {int i 12 / 0;}System.out.println(执行结束);return test;});future.whenComplete(new BiConsumerString, Throwable() {Overridepublic void accept(String t, Throwable action) {System.out.println(t 执行完成);}});future.exceptionally(new FunctionThrowable, String() {Overridepublic String apply(Throwable t) {System.out.println(执行失败 t.getMessage());return 异常xxxx;}}).join(); 执行结束 test 执行完成 或者 执行失败java.lang.ArithmeticException: / by zero null 执行完成 2.5 结果转换 所谓结果转换就是将上一段任务的执行结果作为下一阶段任务的入参参与重新计算产生新的结果。 thenApply thenApply 接收一个函数作为参数使用该函数处理上一个CompletableFuture 调用的结果并返回一个具有处理结果的Future对象。 public U CompletableFutureU thenApply(Function? super T,? extends U fn)public U CompletableFutureU thenApplyAsync(Function? super T,? extends U fn)public U CompletableFutureU thenApplyAsync(Function? super T,? extends U fn, Executor executor) CompletableFutureInteger future CompletableFuture.supplyAsync(() - {int result 100;System.out.println(一阶段 result);return result;}).thenApply(number - {int result number * 3;System.out.println(二阶段 result);return result;});System.out.println(最终结果 future.get()); 一阶段100 二阶段300 最终结果300 thenCompose thenCompose 的参数为一个返回 CompletableFuture 实例的函数该函数的参数是先前计算步骤的结果。 public U CompletableFutureU thenCompose(Function? super T, ? extends CompletionStageU fn);public U CompletableFutureU thenComposeAsync(Function? super T, ? extends CompletionStageU fn) ;public U CompletableFutureU thenComposeAsync(Function? super T, ? extends CompletionStageU fn, Executor executor) ; CompletableFutureInteger future CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number new Random().nextInt(30);System.out.println(第一阶段 number);return number;}}).thenCompose(new FunctionInteger, CompletionStageInteger() {Overridepublic CompletionStageInteger apply(Integer param) {return CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number param * 2;System.out.println(第二阶段 number);return number;}});}});System.out.println(最终结果: future.get()); 第一阶段10 第二阶段20 最终结果20 thenApply 和 thenCompose的区别 thenApply转换的是泛型中的类型并返回一个新的封装了转换结果的 CompletableFuture实例 thenCompose 将内部的 CompletableFuture 调用展开来并使用上一个CompletableFutre 调用的结果在下一步的 CompletableFuture 调用中进行运算是生成一个新的CompletableFuture。 CompletableFutureString future CompletableFuture.supplyAsync(() - Hello);CompletableFutureString result1 future.thenApply(param - param World);CompletableFutureString result2 future.thenCompose(param - CompletableFuture.supplyAsync(() - param World));System.out.println(result1.get());System.out.println(result2.get()); Hello World Hello World 2.6 结果消费 与结果处理和结果转换系列函数返回一个新的 CompletableFuture 不同结果消费系列函数只对结果执行Action而不返回新的计算值。 根据对结果的处理方式结果消费函数又分为 thenAccept系列对单个结果进行消费thenAcceptBoth系列对两个结果进行消费thenRun系列不关心结果只对结果执行Action thenAccept 通过观察该系列函数的参数类型可知它们是函数式接口Consumer这个接口只有输入没有返回值。 public CompletionStageVoid thenAccept(Consumer? super T action);public CompletionStageVoid thenAcceptAsync(Consumer? super T action);public CompletionStageVoid thenAcceptAsync(Consumer? super T action,Executor executor); CompletableFutureVoid future CompletableFuture.supplyAsync(() - {int number new Random().nextInt(10);System.out.println(第一阶段 number);return number;}).thenAccept(number -System.out.println(第二阶段 number * 5));System.out.println(最终结果 future.get()); 第一阶段8 第二阶段40 最终结果null thenAcceptBoth thenAcceptBoth 函数的作用是当两个 CompletionStage 都正常完成计算的时候就会执行提供的action消费两个异步的结果。 public U CompletionStageVoid thenAcceptBoth(CompletionStage? extends U other,BiConsumer? super T, ? super U action);public U CompletionStageVoid thenAcceptBothAsync(CompletionStage? extends U other,BiConsumer? super T, ? super U action);public U CompletionStageVoid thenAcceptBothAsync(CompletionStage? extends U other,BiConsumer? super T, ? super U action,     Executor executor); CompletableFutureInteger futrue1 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number new Random().nextInt(3) 1;try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(第一阶段 number);return number;}});CompletableFutureInteger future2 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number new Random().nextInt(3) 1;try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(第二阶段 number);return number;}});futrue1.thenAcceptBoth(future2, new BiConsumerInteger, Integer() {Overridepublic void accept(Integer x, Integer y) {System.out.println(最终结果 (x y));}}).join(); 第二阶段1 第一阶段2 最终结果3 thenRun thenRun 也是对线程任务结果的一种消费函数与thenAccept不同的是thenRun 会在上一阶段 CompletableFuture 计算完成的时候执行一个RunnableRunnable并不使用该 CompletableFuture 计算的结果。 public CompletionStageVoid thenRun(Runnable action);public CompletionStageVoid thenRunAsync(Runnable action);public CompletionStageVoid thenRunAsync(Runnable action,Executor executor); CompletableFutureVoid future CompletableFuture.supplyAsync(() - {int number new Random().nextInt(10);System.out.println(第一阶段 number);return number;}).thenRun(() -System.out.println(thenRun 执行));System.out.println(最终结果 future.get()); 第一阶段2 thenRun 执行 最终结果null 2.7 结果组合 thenCombine thenCombine 方法合并两个线程任务的结果并进一步处理。 public U,V CompletionStageV thenCombine(CompletionStage? extends U other,BiFunction? super T,? super U,? extends V fn);public U,V CompletionStageV thenCombineAsync(CompletionStage? extends U other,BiFunction? super T,? super U,? extends V fn);public U,V CompletionStageV thenCombineAsync(CompletionStage? extends U other,BiFunction? super T,? super U,? extends V fn,Executor executor); CompletableFutureInteger future1 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number new Random().nextInt(10);System.out.println(第一阶段 number);return number;}});CompletableFutureInteger future2 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number new Random().nextInt(10);System.out.println(第二阶段 number);return number;}});CompletableFutureInteger result future1.thenCombine(future2, new BiFunctionInteger, Integer, Integer() {Overridepublic Integer apply(Integer x, Integer y) {return x y;}});System.out.println(最终结果 result.get()); 第一阶段9 第二阶段5 最终结果14 2.8 任务交互 所谓线程交互是指将两个线程任务获取结果的速度相比较按一定的规则进行下一步处理。 applyToEither 两个线程任务相比较先获得执行结果的就对该结果进行下一步的转化操作。 public U CompletionStageU applyToEither(CompletionStage? extends T other,Function? super T, U fn);public U CompletionStageU applyToEitherAsync(CompletionStage? extends T other,Function? super T, U fn);public U CompletionStageU applyToEitherAsync(CompletionStage? extends T other,Function? super T, U fn,Executor executor); CompletableFutureInteger future1 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number new Random().nextInt(10);System.out.println(第一阶段start number);try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(第一阶段end number);return number;}});CompletableFutureInteger future2 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number new Random().nextInt(10);System.out.println(第二阶段start number);try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(第二阶段end number);return number;}});future1.applyToEither(future2, new FunctionInteger, Integer() {Overridepublic Integer apply(Integer number) {System.out.println(最快结果 number);return number * 2;}}).join(); 第一阶段start6 第二阶段start5 第二阶段end5 最快结果5 acceptEither 两个线程任务相比较先获得执行结果的就对该结果进行下一步的消费操作。 public CompletionStageVoid acceptEither(CompletionStage? extends T other,Consumer? super T action);public CompletionStageVoid acceptEitherAsync(CompletionStage? extends T other,Consumer? super T action);public CompletionStageVoid acceptEitherAsync(CompletionStage? extends T other,Consumer? super T action,Executor executor); CompletableFutureInteger future1 CompletableFuture.supplyAsync(new SupplierInteger() {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;}});CompletableFutureInteger future2 CompletableFuture.supplyAsync(new SupplierInteger() {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 ConsumerInteger() {Overridepublic void accept(Integer number) {System.out.println(最快结果 number);}}).join(); 第二阶段3 最快结果3 runAfterEither 两个线程任务相比较有任何一个执行完成就进行下一步操作不关心运行结果。 public CompletionStageVoid runAfterEither(CompletionStage? other,Runnable action);public CompletionStageVoid runAfterEitherAsync(CompletionStage? other,Runnable action);public CompletionStageVoid runAfterEitherAsync(CompletionStage? other,Runnable action,Executor executor); CompletableFutureInteger future1 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number new Random().nextInt(5);try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(第一阶段 number);return number;}});CompletableFutureInteger future2 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {int number new Random().nextInt(5);try {TimeUnit.SECONDS.sleep(number);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(第二阶段 number);return number;}});future1.runAfterEither(future2, new Runnable() {Overridepublic void run() {System.out.println(已经有一个任务完成了);}}).join();); } }).join(); 第一阶段3 已经有一个任务完成了 runAfterBoth 两个线程任务相比较两个全部执行完成才进行下一步操作不关心运行结果。 public CompletionStageVoid runAfterBoth(CompletionStage? other,Runnable action);public CompletionStageVoid runAfterBothAsync(CompletionStage? other,Runnable action);public CompletionStageVoid runAfterBothAsync(CompletionStage? other,Runnable action,Executor executor); CompletableFutureInteger future1 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(第一阶段1);return 1;}});CompletableFutureInteger future2 CompletableFuture.supplyAsync(new SupplierInteger() {Overridepublic Integer get() {try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(第二阶段2);return 2;}});future1.runAfterBoth(future2, new Runnable() {Overridepublic void run() {System.out.println(上面两个任务都执行完成了。);}}).get(); 第一阶段1 第二阶段2 上面两个任务都执行完成了。 anyOf anyOf 方法的参数是多个给定的 CompletableFuture当其中的任何一个完成时方法返回这个 CompletableFuture。 public static CompletableFutureObject anyOf(CompletableFuture?… cfs) Random random new Random();CompletableFutureString future1 CompletableFuture.supplyAsync(() - {try {TimeUnit.SECONDS.sleep(random.nextInt(5));} catch (InterruptedException e) {e.printStackTrace();}return hello;});CompletableFutureString future2 CompletableFuture.supplyAsync(() - {try {TimeUnit.SECONDS.sleep(random.nextInt(1));} catch (InterruptedException e) {e.printStackTrace();}return world;});CompletableFutureObject result CompletableFuture.anyOf(future1, future2);System.out.println(result.get()); world allOf allOf方法用来实现多 CompletableFuture 的同时返回。 public static CompletableFutureVoid allOf(CompletableFuture?… cfs) CompletableFutureString future1 CompletableFuture.supplyAsync(() - {try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(future1完成);return future1完成;});CompletableFutureString future2 CompletableFuture.supplyAsync(() - {System.out.println(future2完成);return future2完成;});CompletableFutureVoid combindFuture CompletableFuture.allOf(future1, future2);try {combindFuture.get();} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}System.out.println(future1: future1.isDone() future2: future2.isDone()); future2完成 future1完成 future1: truefuture2: true 2.9 使用案例实现最优的“烧水泡茶”程序 著名数学家华罗庚先生在《统筹方法》这篇文章里介绍了一个烧水泡茶的例子文中提到最优的工序应该是下面这样 对于烧水泡茶这个程序一种最优的分工方案用两个线程 T1 和 T2 来完成烧水泡茶程序T1 负责洗水壶、烧开水、泡茶这三道工序T2 负责洗茶壶、洗茶杯、拿茶叶三道工序其中 T1 在执行泡茶这道工序时需要等待 T2 完成拿茶叶的工序。 基于Future实现 public class FutureTaskDemo3{public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建任务T2的FutureTaskFutureTaskString ft2 new FutureTask(new T2Task());// 创建任务T1的FutureTaskFutureTaskString ft1 new FutureTask(new T1Task(ft2));// 线程T1执行任务ft1Thread T1 new Thread(ft1);T1.start();// 线程T2执行任务ft2Thread T2 new Thread(ft2);T2.start();// 等待线程T1执行结果System.out.println(ft1.get());}}// T1Task需要执行的任务// 洗水壶、烧开水、泡茶class T1Task implements CallableString {FutureTaskString ft2;// T1任务需要T2任务的FutureTaskT1Task(FutureTaskString 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 CallableString {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 CompletableFutureDemo2 {public static void main(String[] args) {//任务1洗水壶-烧开水CompletableFutureVoid f1 CompletableFuture.runAsync(() - {System.out.println(T1:洗水壶…);sleep(1, TimeUnit.SECONDS);System.out.println(T1:烧开水…);sleep(15, TimeUnit.SECONDS);});//任务2洗茶壶-洗茶杯-拿茶叶CompletableFutureString 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完成后执行泡茶CompletableFutureString 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) {}}}