异步神器：Java 8 CompletableFuture大揭秘，程序性能爆炸提升

已于 2024-02-26 17:15:43 修改
阅读量1.5k 收藏 15
点赞数 20
分类专栏： Java 文章标签： java python 前端
于 2024-02-26 17:12:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45621658/article/details/136303744
版权

1.简介

在Java中，我们经常需要处理异步的任务，比如调用远程服务，执行耗时的计算，或者等待用户的输入。传统的方法是使用Future接口，它表示一个未完成的操作，可以通过get()方法获取结果，或者通过isDone()方法检查是否完成。但是，Future接口有一些缺点，比如：

  • get()方法是阻塞的，会导致当前线程等待，浪费资源和时间。
  • Future接口没有提供任何方法来处理结果或异常，我们只能手动编写回调逻辑，代码复杂和冗余。
  • Future接口不支持组合多个异步任务，我们只能嵌套多层Future，代码可读性和维护性差。

为了解决这些问题，Java 8引入了一个新的类，叫做CompletableFuture，它实现了Future接口，但是提供了更多的功能和灵活性，比如：

  • CompletableFuture可以通过静态方法或者构造方法创建，可以指定异步任务的执行器，也可以使用默认的ForkJoinPool.commonPool()。
  • CompletableFuture可以通过一系列的方法来处理结果或异常，比如thenApply，thenAccept，thenCompose，thenCombine等，这些方法返回一个新的CompletableFuture，形成了一个流式的编程风格。
  • CompletableFuture可以通过allOf，anyOf等方法来组合多个异步任务，可以实现并行或者并发的效果，提高程序的性能和效率。

本文将介绍CompletableFuture的多种创建方式，结果处理方法，异常处理方法，以及超时问题，希望能够帮助你更好地使用这个强大的类，让你的程序性能起飞。

2.CompletableFuture多种创建方式

CompletableFuture有多种创建方式，我们可以根据不同的场景选择合适的方法。

2.1 CompletableFuture.supplyAsync()

CompletableFuture.supplyAsync()是一个静态方法，它接受一个Supplier类型的参数，表示一个无参有返回值的函数，它会异步地执行这个函数，并返回一个CompletableFuture对象，包含了函数的返回值。我们可以通过thenApply等方法来处理这个返回值，也可以通过get等方法来获取这个返回值。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 处理返回值，打印出来
future.thenAccept(System.out::println);

// 获取返回值，打印出来
try {
    System.out.println(future.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

2.2 CompletableFuture.runAsync()

CompletableFuture.runAsync()也是一个静态方法，它接受一个Runnable类型的参数，表示一个无参无返回值的函数，它会异步地执行这个函数，并返回一个CompletableFuture对象，表示这个函数的执行状态。我们可以通过isDone等方法来检查这个状态，也可以通过join等方法来等待这个函数的完成。例如：

// 创建一个异步任务，打印一句话
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 打印一句话
    System.out.println("Hello, CompletableFuture!");
});

// 检查状态，打印出来
System.out.println(future.isDone());

// 等待完成，打印出来
future.join();
System.out.println(future.isDone());

2.3 CompletableFuture.completedFuture()

CompletableFuture.completedFuture()也是一个静态方法，它接受一个任意类型的参数，表示一个已经完成的值，它会返回一个CompletableFuture对象，包含了这个值。我们可以通过thenApply等方法来处理这个值，也可以通过get等方法来获取这个值。这个方法主要用于测试或者和其他CompletableFuture对象组合。例如：

// 创建一个已经完成的值，为42
CompletableFuture<Integer> future = CompletableFuture.completedFuture(42);

// 处理这个值，打印出来
future.thenAccept(System.out::println);

// 获取这个值，打印出来
try {
    System.out.println(future.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

2.4 CompletableFuture的构造方法

CompletableFuture也可以通过构造方法来创建，它不接受任何参数，表示一个空的CompletableFuture对象，我们可以通过complete，completeExceptionally等方法来手动地设置这个对象的结果或异常。这个方法主要用于自定义异步任务的执行逻辑。例如：

// 创建一个空的CompletableFuture对象
CompletableFuture<String> future = new CompletableFuture<>();

// 在另一个线程中执行异步任务
new Thread(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 根据条件设置结果或异常
    if (Math.random() > 0.5) {
        future.complete("Success");
    } else {
        future.completeExceptionally(new RuntimeException("Failure"));
    }
}).start();

// 处理结果或异常，打印出来
future.whenComplete((result, exception) -> {
    if (exception == null) {
        System.out.println(result);
    } else {
        System.out.println(exception.getMessage());
    }
});

3.CompletableFuture的结果

CompletableFuture提供了一系列的方法来处理结果或异常，这些方法都返回一个新的CompletableFuture对象，形成了一个流式的编程风格。我们可以根据不同的场景选择合适的方法。

3.1 get()方法

get()方法是从Future接口继承的方法，它用于获取CompletableFuture对象的结果，如果结果还没有完成，它会阻塞当前线程，直到结果完成。它会抛出InterruptedException或者ExecutionException异常，如果异步任务被中断或者出现异常。这个方法比较简单，但是不推荐使用，因为它会导致线程等待，浪费资源和时间。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 获取结果，打印出来
try {
    System.out.println(future.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

3.2 thenApply()方法

thenApply()方法是一个实例方法，它接受一个Function类型的参数，表示一个有参有返回值的函数，它会在CompletableFuture对象的结果完成后，异步地执行这个函数，并返回一个新的CompletableFuture对象，包含了函数的返回值。我们可以通过thenApply等方法来处理这个返回值，也可以通过get等方法来获取这个返回值。这个方法主要用于对结果进行转换或者处理，比如加工，过滤，验证等。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 对结果进行转换，乘以2
CompletableFuture<Integer> doubledFuture = future.thenApply(x -> x * 2);

// 获取转换后的结果，打印出来
try {
    System.out.println(doubledFuture.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

3.3 thenAccept()方法

thenAccept()方法是一个实例方法，它接受一个Consumer类型的参数，表示一个有参无返回值的函数，它会在CompletableFuture对象的结果完成后，异步地执行这个函数，并返回一个新的CompletableFuture对象，表示这个函数的执行状态。我们可以通过isDone等方法来检查这个状态，也可以通过join等方法来等待这个函数的完成。这个方法主要用于对结果进行消费或者输出，比如打印，存储，发送等。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 对结果进行消费，打印出来
CompletableFuture<Void> printFuture = future.thenAccept(System.out::println);

// 检查状态，打印出来
System.out.println(printFuture.isDone());

// 等待完成，打印出来
printFuture.join();
System.out.println(printFuture.isDone());

3.4 thenCompose()方法

thenCompose()方法是一个实例方法，它接受一个Function类型的参数，表示一个有参有返回值的函数，它会在CompletableFuture对象的结果完成后，异步地执行这个函数，并返回一个新的CompletableFuture对象，包含了函数的返回值。这个函数的返回值必须是一个CompletableFuture对象，表示一个依赖于前一个结果的异步任务。这个方法主要用于将两个异步任务串联起来，形成一个扁平的结构，而不是嵌套的结构。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 创建一个依赖于前一个结果的异步任务，返回一个字符串
CompletableFuture<String> future2 = future1.thenCompose(x -> CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个字符串
    return "The number is " + x;
}));

// 获取结果，打印出来
try {
    System.out.println(future2.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

3.5 thenCombine()方法

thenCombine()方法是一个实例方法，它接受两个参数，一个是另一个CompletableFuture对象，表示一个和当前对象并行的异步任务，另一个是一个BiFunction类型的参数，表示一个有两个参数有返回值的函数，它会在两个CompletableFuture对象的结果都完成后，异步地执行这个函数，并返回一个新的CompletableFuture对象，包含了函数的返回值。这个方法主要用于将两个异步任务合并起来，形成一个新的异步任务。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 创建另一个异步任务，返回一个随机数
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 将两个异步任务合并，求和
CompletableFuture<Integer> sumFuture = future1.thenCombine(future2, Integer::sum);

// 获取结果，打印出来
try {
    System.out.println(sumFuture.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

4.处理CompletableFuture的异常

CompletableFuture提供了一些方法来处理异常，这些方法都返回一个新的CompletableFuture对象，包含了异常处理后的结果或异常。我们可以根据不同的场景选择合适的方法。

4.1 exceptionally()方法

exceptionally()方法是一个实例方法，它接受一个Function类型的参数，表示一个有参有返回值的函数，它会在CompletableFuture对象出现异常时，异步地执行这个函数，并返回一个新的CompletableFuture对象，包含了函数的返回值。这个函数的参数是一个Throwable对象，表示异常的原因，它的返回值是一个任意类型的对象，表示异常处理后的结果。这个方法主要用于提供一个默认的结果，或者记录一个日志，或者抛出一个新的异常。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 抛出一个异常
    throw new RuntimeException("Something went wrong");
});

// 处理异常，提供一个默认的结果
CompletableFuture<Integer> defaultFuture = future.exceptionally(e -> {
    // 打印异常信息
    System.out.println(e.getMessage());
    // 返回一个默认值
    return 0;
});

// 获取结果，打印出来
try {
    System.out.println(defaultFuture.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

4.2 handle()方法

handle()方法是一个实例方法，它接受一个BiFunction类型的参数，表示一个有两个参数有返回值的函数，它会在CompletableFuture对象的结果完成或出现异常时，异步地执行这个函数，并返回一个新的CompletableFuture对象，包含了函数的返回值。这个函数的第一个参数是一个任意类型的对象，表示结果的值，如果出现异常，这个值为null，第二个参数是一个Throwable对象，表示异常的原因，如果没有异常，这个值为null，它的返回值是一个任意类型的对象，表示异常处理后的结果。这个方法主要用于对结果或异常进行统一的处理，比如转换，过滤，验证等。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 根据条件抛出一个异常
    if (Math.random() > 0.5) {
        throw new RuntimeException("Something went wrong");
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 处理结果或异常，转换为一个字符串
CompletableFuture<String> stringFuture = future.handle((result, exception) -> {
    if (exception == null) {
        return "The number is " + result;
    } else {
        return "The error is " + exception.getMessage();
    }
});

// 获取结果，打印出来
try {
    System.out.println(stringFuture.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

5.超时问题

CompletableFuture提供了一些方法来处理超时问题，这些方法都返回一个新的CompletableFuture对象，包含了超时处理后的结果或异常。我们可以根据不同的场景选择合适的方法。

5.1 orTimeout()方法

orTimeout()方法是一个实例方法，它接受两个参数，一个是一个long类型的参数，表示超时的时间，另一个是一个TimeUnit类型的参数，表示时间的单位，它会在CompletableFuture对象的结果完成或超过指定的时间后，返回一个新的CompletableFuture对象，包含了结果或异常。如果超过了指定的时间，这个对象会包含一个TimeoutException异常，表示超时的原因。这个方法主要用于设置一个最大的等待时间，防止异步任务无限期地延迟。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 设置一个超时时间，为1秒
CompletableFuture<Integer> timeoutFuture = future.orTimeout(1, TimeUnit.SECONDS);

// 获取结果，打印出来
try {
    System.out.println(timeoutFuture.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

5.2 completeOnTimeout()方法

completeOnTimeout()方法是一个实例方法，它接受三个参数，一个是一个任意类型的参数，表示一个默认的结果，另一个是一个long类型的参数，表示超时的时间，最后一个是一个TimeUnit类型的参数，表示时间的单位，它会在CompletableFuture对象的结果完成或超过指定的时间后，返回一个新的CompletableFuture对象，包含了结果或默认的结果。如果超过了指定的时间，这个对象会包含一个默认的结果，而不是一个异常。这个方法主要用于提供一个备选的结果，或者记录一个日志，或者抛出一个新的异常。例如：

// 创建一个异步任务，返回一个随机数
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 返回一个随机数
    return new Random().nextInt(100);
});

// 设置一个超时时间，为1秒，和一个默认的结果，为0
CompletableFuture<Integer> defaultFuture = future.completeOnTimeout(0, 1, TimeUnit.SECONDS);

// 获取结果，打印出来
try {
    System.out.println(defaultFuture.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

6.总结

本文介绍了CompletableFuture的多种创建方式，结果处理方法，异常处理方法，以及超时问题，希望能够帮助你更好地使用这个强大的类，让你的程序性能起飞。CompletableFuture是Java 8中的一个重要的特性，它可以让我们更方便地编写异步的代码，提高程序的并发性和效率，也可以让我们的代码更简洁和优雅，避免了传统的Future接口的一些缺点和限制。如果你想了解更多关于CompletableFuture的内容，你可以参考以下的资源：

程序员Q仔
关注
  • 20
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java中的异步编程：使用CompletableFuture
程序员光剑
07-19 2807
作者：禅与计算机程序设计艺术 在Java中进行异步编程一直是一种困难甚至不可能的事情。由于各种历史原因、一些被遗忘的实现细节、线程池等问题导致了编写异步代码的困难和复杂性。最近的OpenJDK版本引入了一个新特性——CompletableFuture，它提供了一个全新的并发模型——Reactive Streams，用于编写响应式异步流处理
Java之CompletableFuture异步、组合计算基本用法
OceanSky的专栏
10-29 3855
CompletableFuture是Java8新增的Api,该类实现了Future和ComplateStage两个接口，提供了强大的Future扩展功能，可以简化异步编程的复杂性，提供了函数编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。 Future:表示一个任务的生命周期，并提供了相应的方法来判断是否已经完成或取消，以及获取任务的...
我惊了！CompletableFuture居然有性能问题！
java_xiaoo的博客
10-09 2164
国庆的时候闲来无事，就随手写了一点之前说的比赛的代码，目标就是保住前 100 混个大赛的文化衫就行了。 现在还混在前 50 的队伍里面，稳的一比。 其实我觉得大家做柔性负载均衡那题的思路其实都不会差太多，就看谁能把关键的信息收集起来并利用上了。 由于是基于 Dubbo 去做的嘛，调试的过程中，写着写着我看到了这个地方： org.apache.dubbo.rpc.protocol.AbstractInvoker#waitForResultIfSync 先看我框起来的这一行代码，ays..
CompletableFuture详解
最新发布
weixin_43527947的博客
08-06 2626
在JAVA8开始引入了全新的类，它是Future接口的一个实现类。也就是在Future接口的基础上，额外封装提供了一些执行方法，用来解决Future使用场景中的一些不足，对流水线处理能力提供了支持。当我们需要进行异步处理的时候，我们可以通过方法，传入一个具体的要执行的处理逻辑函数，这样就轻松的完成了CompletableFuture的创建与触发执行。方法名称作用描述静态方法，用于构建一个对象，并异步执行传入的参数，允许执行函数有返回值runAsync静态方法，用于构建一个。
CompletableFuture（二）
ZERO
01-24 5735
转载自：http://www.jb51.net/article/51163.htm 创造和获取CompletableFuture static CompletableFuture supplyAsync(Supplier supplier); static CompletableFuture supplyAsync(Supplier supplier, Executor exe
Java CompletableFuture 详解
橙子wj的博客
05-21 2662
出处： http://colobu.com/2016/02/29/Java-CompletableFuture/Future是Java 5添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel方法停止任务的执行。虽然Future以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不
Java 8 CompletableFuture
weixin_34257076的博客
08-19 90
原文：Java 8 CompletableFutures Part I 作者：Bill Bejeck 译者：noONE 译者前言 JDK1.5就增加了Future接口，但是接口使用不是很能满足异步开发的需求，使用起来不是那么友好。所以出现了很多第三方封装的Future，Guava中就提供了一个更好的ListenableFuture 类，Netty中则提供了一个自己的Future。所以，Ja...
一万两千字，一文讲懂如何使用​​CompletableFuture
weixin_36199904的博客
06-30 108
CompletableFuture 是 Java 8 引入的一个类，用于简化异步编程模型。它是 Future 接口的一个增强版本，提供了更加丰富的功能和更灵活的用法。CompletableFuture 允许开发者以一种声明式和链式的方式编写异步代码，这样可以提高代码的可读性和可维护性。CompletableFuture的定...
CompleteableFuture
qq_41139119的博客
05-30 919
计算可以由 Future ，Consumer 或者 Runnable 接口中的 apply，accept 或者 run等方法表示。计算的执行主要有以下2.1. 默认执行2.2. 使用默认的CompletionStage的异步执行提供者异步执行。这些方法名使用someActionAsync这种格式表示。2.3. 使用 Executor 提供者异步执行。这些方法同样也是someActionAsync这种格式，但是会增加一个Executor 参数。
CompletableFutureExamples:使用Java的CompletableFuture进行异步编程的示例
05-09
通过学习这些示例，你可以深入理解如何在实际项目中利用`CompletableFuture`进行高效的异步编程，提升程序的并发性能。记得查看源代码，仔细分析每个示例的实现逻辑，这将有助于你掌握这一强大的工具。
20个实例玩转 Java 8 异步神器 CompletableFuture.pdf
11-18
Java 8 引入的 CompletableFuture 是一种强大的工具，用于处理异步编程和构建复杂的异步计算流程。它实现了 CompletionStage 接口，这个接口定义了一种计算阶段，该阶段可以同步或异步地完成，并且可以与其他阶段...
Java并发 CompletableFuture异步编程的实现
08-25
Java并发 CompletableFuture异步编程的实现 在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而...
Java8异步类CompletableFuture详解
CharlesYooSky的博客
09-01 2332
JDK8引入了一个新的类CompletableFuture
CompletableFuture
我这个代码你能看懂吗？
07-15 960
提供了丰富的 API 来处理异步任务，包括任务的创建、组合、异常处理、超时处理等。通过这些 API，你可以轻松地实现复杂的异步编程逻辑。
基础篇：异步编程不会？我教你啊！CompletableFuture（JDK1.8）
潜行前行的专栏
12-05 3439
以前需要异步执行一个任务时，一般是用Thread或者线程池Executor去创建。如果需要返回值，则是调用Executor.submit获取Future。但是多个线程存在依赖组合，我们又能怎么办？可使用同步组件CountDownLatch、CyclicBarrier等；其实有简单的方法，就是用CompeletableFuture
用好CompletableFuture类，性能起飞
tszc95的博客
10-08 375
Java 8中引入了CompletableFuture类，它是一种方便的异步编程工具，其可以对多数据源之间的请求的流程编排，可以处理各种异步操作，如网络请求、文件IO和数据库操作等。它是Java的Future接口的扩展，提供了一些有用的方法来创建、操作和组合异步操作。本文将详细介绍CompletableFuture的使用方式。
3 CompletableFuture
学习 | 共享 | 前进
06-03 4713
6.3-02CompletableFuture学习
手把手教学妹CompletableFuture异步化,性能关系直接起飞!
JavaEdge全是干货的技术号
04-18 2796
Guava 的冲击 由于 JDK1.5 Futrure 的 get 方法获取任务结果必须阻塞等待，Google 看不下去了，开发了 Guava 库 public static void main(String[] args) throws Exception { // 装饰器模式 ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(2
04-CompletableFuture异步线程 性能
彼岸舞的博客
04-11 304
场景 场景 方法 任务少, 不频繁 直接使用线程 任务数稳定,频繁 使用线程池 线程池 优点 不用频繁的创建和销毁线程 不需要担心OOM 直接往任务队列添加任务即可 核心线程忙不过来,可以自动增加到最大线程数 构造参数 核心线程数 最大线程数 空闲活跃时长 时长单位 阻塞队列 线程工厂 拒绝策略 直接丢弃 替换最后一个 ...
java8 completablefuture
04-29
Java 8的CompletableFuture是异步编程的重要特性之一。它是一个用于实现异步计算的Future，并且可以根据计算结果执行连续的操作。CompletableFuture在处理异步任务时，可以将任务分为两个部分：上游生产数据和下游处理数据。上游生产数据的任务被视为生产者，下游处理数据的任务被视为消费者。 使用CompletableFuture时，可以通过链式操作串联所有的操作，实现数据的转换和处理。在这个过程中，当某个操作执行完成后，会自动通知下一个操作继续执行。与此同时，CompletableFuture还支持各种回调函数，可以在任务执行成功或失败时进行回调处理，从而更好地控制任务的执行。 在使用CompletableFuture时，可以很方便地实现并行计算。CompletableFuture自带了线程池，可以将计算任务分配到不同的线程上执行，从而提高处理效率。此外，通过使用CompletableFuture，可以避免了手动处理线程的问题，使得异步编程更加简便和实用。 总之，CompletableFuture是Java 8提供的一个强大的异步编程工具，可以有效地提高程序的响应速度和执行效率。它不仅简化了异步编程的难度，同时也提供了强大的回调函数和并行处理能力，可以在实现高效并发处理时大有用处。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值