Java8-02-CompletableFuture续

最新推荐文章于 2024-06-07 08:25:31 发布
最新推荐文章于 2024-06-07 08:25:31 发布
阅读量79 收藏
点赞数
分类专栏： # Java基础 文章标签： java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ycmy2017/article/details/128899112
版权

1-两个任务组合,都要完成

* thenCombine:两个任务都要完成，组合两个future，获取两个future的返回结果，并返回当前任务的返回值

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)

 public static void main10() throws Exception {
        System.out.println("main start....");


        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {

            }
            int i = 100 / 10;
            System.out.println("运行结果:" + i + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return i;
        }, executorService);

        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            String result="hello";
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {

            }
            System.out.println("运行结果:" + result+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return result;
        }, executorService);

        CompletableFuture<String> completableFuture = future01.thenCombineAsync(future02, (res1, res2) -> {
            System.out.println("当前线程3：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            System.out.println("任务1结果:" + res1 + "---->任务2结果:" + res2);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {

            }
            return res1 + res2;
        }, executorService);
        System.out.println("最后返回结果:"+completableFuture.get()+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        System.out.println("main end....");

    }

/**

* thenCombineAsync

* <p>

* 输出结果：

main start....

当前线程1：13->当前时间:2021-10-18 11:40:12

当前线程2：14->当前时间:2021-10-18 11:40:12

运行结果:hello->当前时间:2021-10-18 11:40:14

运行结果:10->当前时间:2021-10-18 11:40:16

当前线程3：15->当前时间:2021-10-18 11:40:16

任务1结果:10---->任务2结果:hello

最后返回结果:10hello->当前时间:2021-10-18 11:40:19

main end....

*/

* thenAcceptBoth：两个任务都要完成，组合两个future，获取两个future的返回结果，然后处理任务，没有返回值

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

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

public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action, Executor executor)

public static void main11() throws Exception {
        System.out.println("main start....");


        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {

            }
            int i = 100 / 10;
            System.out.println("运行结果:" + i + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return i;
        }, executorService);

        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            String result="hello";
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {

            }
            System.out.println("运行结果:" + result+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return result;
        }, executorService);

        CompletableFuture<Void> completableFuture = future01.thenAcceptBothAsync(future02, (res1, res2) -> {
            System.out.println("当前线程3：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            System.out.println("任务1结果:" + res1 + "---->任务2结果:" + res2);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
            }
            System.out.println("任务1结果:" + res1 + "---->任务2结果:" + res2 + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        }, executorService);
        System.out.println("最后返回结果:"+completableFuture.get()+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        System.out.println("main end....");

    }

/**

* thenAcceptBoth

* <p>

* 输出结果：

main start....

当前线程2：14->当前时间:2021-10-18 11:46:03

当前线程1：13->当前时间:2021-10-18 11:46:03

运行结果:hello->当前时间:2021-10-18 11:46:05

运行结果:10->当前时间:2021-10-18 11:46:07

当前线程3：15->当前时间:2021-10-18 11:46:07

任务1结果:10---->任务2结果:hello

任务1结果:10---->任务2结果:hello->当前时间:2021-10-18 11:46:10

最后返回结果:null->当前时间:2021-10-18 11:46:10

main end....

*/

*runAfterBoth：两个任务都要完成，组合两个future，不需要获取两个future的返回结果，只需要两个future完成任务后，处理该任务

public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other,Runnable action)

public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action)

public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor executor)

 public static void main12() throws Exception {
        System.out.println("main start....");


        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {

            }
            int i = 100 / 10;
            System.out.println("运行结果:" + i + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return i;
        }, executorService);

        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            String result="hello";
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {

            }
            System.out.println("运行结果:" + result+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return result;
        }, executorService);

        CompletableFuture<Void> completableFuture = future01.runAfterBothAsync(future02, () -> {
            System.out.println("当前线程3：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            System.out.println("不需要两个future的结果，自己执行");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
            }
            System.out.println("不需要两个future的结果，自己执行"+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        }, executorService);
        System.out.println("最后返回结果:"+completableFuture.get()+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        System.out.println("main end....");

    }

/**

* runAfterBothAsync

* <p>

* 输出结果：

main start....

当前线程1：13->当前时间:2021-10-18 11:48:27

当前线程2：14->当前时间:2021-10-18 11:48:27

运行结果:hello->当前时间:2021-10-18 11:48:29

运行结果:10->当前时间:2021-10-18 11:48:31

当前线程3：15->当前时间:2021-10-18 11:48:31

不需要两个future的结果，自己执行

不需要两个future的结果，自己执行->当前时间:2021-10-18 11:48:34

最后返回结果:null->当前时间:2021-10-18 11:48:34

main end....

*/

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

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

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

public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn,Executor executor)

public static void main13() throws Exception {
        System.out.println("main start....");
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {

            }
            int i = 100 / 10;
            System.out.println("运行结果:" + i + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return i;
        }, executorService);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            String result="hello";
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {

            }
            System.out.println("运行结果:" + result+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return result;
        }, executorService);

        CompletableFuture<String> completableFuture = future01.applyToEitherAsync(future02, (res) -> {
            System.out.println("当前线程3：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            //这里两个future返回值类型必须一致，否则不知道用哪个
            System.out.println("两个future的任意一个的结果,res=" + res);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
            }
            System.out.println("两个future的任意一个的结果,res=" + res + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return "world:" + res;
        }, executorService);
        System.out.println("最后返回结果:"+completableFuture.get()+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        System.out.println("main end....");

    }

* applyToEitherAsync

* <p>

* 输出结果：

main start....

当前线程2：14->当前时间:2021-10-18 13:49:38

当前线程1：13->当前时间:2021-10-18 13:49:38

运行结果:hello->当前时间:2021-10-18 13:49:40

当前线程3：15->当前时间:2021-10-18 13:49:40

两个future的任意一个的结果,res=hello

运行结果:10->当前时间:2021-10-18 13:49:42

两个future的任意一个的结果,res=hello->当前时间:2021-10-18 13:49:43

最后返回结果:world:hello->当前时间:2021-10-18 13:49:43

main end....

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

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

public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,Executor executor)

public CompletableFuture<Void> runAfterEither(CompletionStage<?> other,Runnable action)

public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action)

public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor)

3-多任务组合

*allOf:等待所有任务完成

*anyOf：只要有一个任务完成

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

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

ps:allOf方法使用场景：比如电商系统中商品详情页，三个查询：查询商品图片，查询商品属性，查询商品描述；可以分解三个查询，同时查询，最后等待三个查询完成得到结果

public static void main14() throws Exception {
        System.out.println("main start....");
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {

            }
            int i = 100 / 10;
            System.out.println("运行结果:" + i + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return i;
        }, executorService);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            String result="hello";
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {

            }
            System.out.println("运行结果:" + result+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return result;
        }, executorService);

        CompletableFuture<Void> completableFuture = CompletableFuture.allOf(future01,future02);
        completableFuture.get();
        System.out.println("最后返回结果"+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        System.out.println("main end....");

    }

/**

*

* <p>

* 输出结果：

*

main start....

当前线程1：13->当前时间:2021-10-18 14:18:38

当前线程2：14->当前时间:2021-10-18 14:18:38

运行结果:hello->当前时间:2021-10-18 14:18:40

运行结果:10->当前时间:2021-10-18 14:18:42

最后返回结果->当前时间:2021-10-18 14:18:42

main end....

*/

4-CompletionService

CompletionService的实现原理是内部维护了一个阻塞队列，当任务执行结束就把任务的执行结果加入到阻塞队列中。

 public static void main16() throws Exception {
        System.out.println("main start...."+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        CompletionService<String> completionService = new ExecutorCompletionService<>(executorService);
        for(int i=1;i<=3;i++){
            final int j=i;
            completionService.submit(() -> {
                System.out.println("线程：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"第几次:"+j);
                String shopInfo = getShopInfo(j);
                return shopInfo;
            });
        }
        for(int i=1;i<=3;i++){
            try{
                System.out.println( "执行->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                String res = completionService.take().get(6L,TimeUnit.SECONDS);
                System.out.println("获取结果线程：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"第几次:"+i+"获取值为:"+res);
            }catch(Exception e){
                System.out.println("获取结果线程error：" + Thread.currentThread().getId() + "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"第几次:"+i+"获取值为000");
            }
        }
        System.out.println("main end...."+ "->当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }


public static String getShopInfo(int i) throws Exception{
        if(i==1){
            TimeUnit.SECONDS.sleep(5);
            return "A";
        }
        if(i==2){
            TimeUnit.SECONDS.sleep(8);
            int aa=10/0;
            return "B";
        }
        if(i==3){
            TimeUnit.SECONDS.sleep(4);
            return "C";
        }
        return "D";
    }

/**

* CompletionService 应用场景

* 比如我们平台【医药平台】 需要去每个药店A.B.C查询结果，

* 如果串行化，比如A药店需要5秒；B药店需要8秒；C药店需要4秒，那么系统一共5+8+4=17秒

* 如果并行化，那么最多就是8秒；

*

* 如果我们进一步优化，比如要求7秒内有结果，还可以设置获取值是7秒时间【通过http请求设置超时时间】，丢弃B药店8秒

*

*

*main start....->当前时间:2021-10-18 14:49:13

* 执行->当前时间:2021-10-18 14:49:13

* 线程：13->当前时间:2021-10-18 14:49:13第几次:1

* 线程：15->当前时间:2021-10-18 14:49:13第几次:3

* 线程：14->当前时间:2021-10-18 14:49:13第几次:2

* 获取结果线程：1->当前时间:2021-10-18 14:49:17第几次:1获取值为:C

* 执行->当前时间:2021-10-18 14:49:17

* 获取结果线程：1->当前时间:2021-10-18 14:49:18第几次:2获取值为:A

* 执行->当前时间:2021-10-18 14:49:18

* 获取结果线程error：1->当前时间:2021-10-18 14:49:21第几次:3获取值为000

* main end....->当前时间:2021-10-18 14:49:21

*

*/

ycmy2017
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
java future专题 2-1 CompletableFuture源码探秘-基础用法（1）
xxcupid的博客
04-01 412
todo
Java8-Deitel:Estudando Java 8从头到尾Deitel
03-26
Java 8-Como Programar-Deitel Estudando Java 8从头到尾Deitel 费拉门塔斯 因此：Ubuntu 18.04 / Windows 10 蚀 卡皮图洛02 示例02.01 示例02.03 示例02.04 示例02.06 示例02.07 示例02.15 练习02.06 ...
CompletableFuture异步编排（两任务组合——两个任务必须都完成才触发另一个任务 ）
小志的博客
08-23 1202
CompletableFuture异步编排（两任务组合——两个任务必须都完成才触发另一个任务 ）
多个CompletableFuture重复写如何简化，封装，复用，让同事们耳目一新的写法，这里给你答案
qq_38349413的博客
05-10 825
多个CompletableFuture重复写简化，Supplier函数如何封装，怎么结合泛型到自己的代码中，不做屎山攻城狮，让同事耳目一新的写法，我来教你
Java CompletableFuture
qq_33240556的博客
05-29 157
提供了强大的异步编程能力，使得处理复杂的异步逻辑变得更加简单和直观。通过使用它的丰富 API，可以轻松地处理任务的完成、合并结果和异常处理等操作，从而大大简化了异步编程的复杂性。
Java多线程工具CompletableFuture
m0_73330311的博客
08-21 462
Future的问题写多线程程序的时候，可以使用Future从一个异步线程中拿到结果，但是如果使用过程中会发现一些问题：如果想要对Future的结果做进一步的操作，需要阻塞当前线程多个Future不能被链式的执行，每个Future的结果都是独立的，期望对一个Future的结果做另外一件异步的事情；没有异常处理策略，如果Future执行失败了，需要手动捕捉CompletableFuture应运而生。
javafuture源码-demo-java-completablefuture:“带有CompletableFuture的Java异步编程”
05-22
java future源码Java中具有CompletableFuture的异步...8添加（并更新了Java 9和Java 12） CompletionStage接口及其基本实现CompletableFuture类。 这些类允许构建有效且流畅的多级异步计算。 但是，CompletableFutur
Java8 CompletableFuture详解
09-04
主要介绍了Java8 CompletableFuture详解,CompletableFuture extends Future提供了方法，一元操作符和促进异步性以及事件驱动编程模型,需要的朋友可以参考下
java-8-openjdk-amd64
04-20
java-8-openjdk-amd64.tar.gz
mysql-connector-java-8.0.22.jar
08-14
包含mysql-connector-java-8.0.22.jar包含mysql-connector-java-8.0.22.jar包含mysql-connector-java-8.0.22.jar包含mysql-connector-java-8.0.22.jar包含mysql-connector-java-8.0.22.jar包含mysql-connector-java-...
使用 CompletableFuture 实现所有任务都执行完之后在执行下一步操作
weixin_43440709的博客
03-31 6348
方法接收一个 CompletableFuture 数组，当所有 CompletableFuture 都完成时，它将返回一个新的 CompletableFuture，该 CompletableFuture 不包含任何结果，但表示所有任务都已完成。在 CompletableFuture 中实现所有任务都执行完之后再执行下一步操作，我们可以使用。方法在其上执行下一步操作。如果我们需要使用上一步的计算结果来执行下一步操作，我们应该使用。方法在所有任务完成后执行下一步操作。方法创建了三个异步任务，并使用。
CompletableFuture的使用
Evan's Blog ٩(๑❛ᴗ❛๑)۶
03-20 8492
现在大部分的CPU都是多核，我们都知道想要提升我们应用程序的运行效率，就必须得充分利用多核CPU的计算能力；Java为我们提供了大量多线程API，使用它们可以让我们的代码避免同步阻塞，从而达到提升运行效率的目的，CompletableFuture就是其中一个非常强大且重要API，下面我们就来介绍一下CompletableFuture的概念和使用。
Java多线程之CompletableFuture
热门推荐
上善若泪
04-28 2万+
文章目录1 CompletableFuture1.1 简介1.2 创建CompletableFuture1.2.1 构造函数创建1.2.2 supplyAsync创建1.2.3 runAsync创建1.3 异步回调方法1.3.1 thenApply / thenAccept / thenRun互相依赖1.3.1.1 thenApply1.3.1.2 thenAccept / thenRun1.3.2 exceptionally有返回1.3.3 whenComplete无返回1.3.4 handle有返回1.
java环境部署
JiuMeilove的博客
06-04 403
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
finereport 9.0 Tomcat 集群-来自帆软
最新发布
chenmingfa110的博客
06-07 842
APACHE_HOME ％为你的安装目录。对于每个新来的session，Apache按照节点配置中的lbfactor比重选择访问节点，如果某节点node1不能访问，则寻找下一可访问节点，并且将此node1就在该访问session的访问黑名单中，以后该session的访问直接不考虑node1，即使node1又可以访问了。注：由于这里三个tomcat全在一台机器上，所以需要修改三种类型的端口号，如果是在不同的机器上，则只需要修改AJP13的connector的port，其他端口号不需要修改。
java中Overload和Override的区别
codedadi的博客
06-04 586
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 1435
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 641
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
Java-02基本语法-02-StringBuilder
09-16
引用: StringBuilder是Java中的一个类，它可以用来进行字符串的操作和修改。通过调用toString()方法，可以将StringBuilder对象转换为字符串。例如，str = builder.toString()可以获取到StringBuilder内部表示的修改...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值