谷粒商城实战笔记-195~202-商城业务-异步-CompletableFuture

最新推荐文章于 2024-09-17 23:15:52 发布
最新推荐文章于 2024-09-17 23:15:52 发布
阅读量649 收藏 14
点赞数 23
分类专栏： 谷粒商城 文章标签： 笔记 java 谷粒商城
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/epitomizelu/article/details/141205675
版权

文章目录


这一部分介绍CompletableFuture线程编排的使用。

  • 195-商城业务-异步-CompletableFuture
  • 196-商城业务-异步-CompletableFuture-启动异步任务
  • 197-商城业务-异步-CompletableFuture-完成回调与异常感知
  • 198-商城业务-异步-CompletableFuture-handle最终处理
  • 199-商城业务-异步-CompletableFuture-线程串行化
  • 200-商城业务-异步-CompletableFuture-两任务组合-都要完成
  • 201-商城业务-异步-CompletableFuture-两任务组合-一个完成
  • 202-商城业务-异步-CompletableFuture-多任务组合

一，CompletableFuture简介

商品详情页的业务场景涉及到多个步骤，每个步骤都需要一定的时间来完成。具体来说，这些步骤包括：

  1. 获取SKU的基本信息，耗时0.5秒。
  2. 获取SKU的图片信息，耗时0.5秒。
  3. 获取SKU的促销信息，耗时1秒。
  4. 获取SPU的所有销售属性，耗时1秒。
  5. 获取规格参数组及组下的规格参数，耗时1.5秒。
  6. 获取SPU详情，耗时1秒。

如果按照顺序执行这些步骤，总耗时将是6.5秒。

对于用户来说，等待这么长的时间来加载一个页面是不可接受的，尤其是在网络购物体验中，快速响应是提升用户体验的关键因素。

使用多线程的必要性：

  1. 提高响应速度：通过使用多线程，可以将这些步骤并行化，从而显著减少用户等待时间。如果这些步骤能够同时进行，理论上总耗时可以缩短至最长步骤的时间，即1.5秒。

  2. 资源利用优化：在某些步骤等待数据（如远程调用）时，其他线程可以继续执行其他任务，这样可以更有效地利用CPU资源。

  3. 改善用户体验：用户对页面加载速度非常敏感，多线程可以加快页面内容的呈现速度，提升用户体验。

  4. 并行处理：在多步骤的业务逻辑中，很多步骤可以独立进行，没有依赖关系。多线程允许这些步骤并行处理，而不是串行等待。

  5. 异步加载：现代Web应用常常采用异步加载的方式，即先展示页面的基础结构，然后逐步加载其他数据。多线程可以支持这种模式，先快速展示基本信息，再逐步补充其他内容。

CompletableFuture

CompletableFuture 是 Java 8 引入的一个非常重要的类，它提供了一种异步编程的解决方案，用于编写非阻塞的、基于回调的代码。CompletableFuture 允许你以声明性的方式处理异步操作，使得代码更加简洁和易于管理。

以下是 CompletableFuture 的一些关键特性：

  1. 异步执行：CompletableFuture 可以异步执行任务，而不会阻塞当前线程。

  2. 链式调用：通过方法引用和 lambda 表达式，CompletableFuture 支持链式调用，允许你将多个异步操作链接在一起。

  3. 回调：你可以为 CompletableFuture 添加回调方法，当操作完成或发生异常时，这些回调将被执行。

  4. 组合操作：CompletableFuture 允许你组合多个异步操作，例如 thenCombine、thenAcceptBoth 等。

  5. 异常处理：CompletableFuture 提供了 exceptionally 方法，用于处理异步操作中发生的异常。

  6. 转换结果：CompletableFuture 的 thenApply 方法可以用来转换异步操作的结果。

  7. 等待完成：CompletableFuture 的 get 方法可以等待异步操作完成，并返回结果。

  8. 取消操作：CompletableFuture 支持取消尚未完成的异步操作。

以下是一个简单的 CompletableFuture 示例，演示了如何使用它来异步执行任务并处理结果：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 创建一个CompletableFuture任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000); // 模拟耗时操作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "Hello, CompletableFuture!";
        });

        // 添加回调来处理结果
        future.thenAccept(result -> {
            System.out.println("Received result: " + result);
        });

        // 转换结果
        CompletableFuture<Integer> transformed = future.thenApply(s -> s.length());

        // 等待转换结果并处理
        try {
            int resultLength = transformed.get();
            System.out.println("Result length: " + resultLength);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，创建了一个异步任务来返回一个字符串，然后通过 thenAccept 方法添加了一个回调来处理这个结果。

接着使用 thenApply 方法将结果转换为字符串的长度，并等待这个转换结果。CompletableFuture 使得整个异步处理过程变得简单而清晰。

二，CompletableFuture-启动异步任务的四个方法

CompletableFuture类提供的四个静态方法，它们都是异步执行任务的方法。

  1. static CompletableFuture<Void> runAsync(Runnable runnable)
    这个方法接受一个Runnable对象作为参数，用于异步执行一个无返回值的任务。该方法内部会使用ForkJoinPool.commonPool()作为默认的线程池来执行任务。例如：

    CompletableFuture.runAsync(() -> {
    System.out.println("Task executed asynchronously");
});

    上面的代码会异步执行打印语句。

  2. public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
    这个方法与上一个方法类似，但是允许用户自定义线程池来执行任务。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture.runAsync(() -> {
    System.out.println("Task executed asynchronously using custom executor");
}, executor);

    上面的代码会使用一个包含5个线程的固定线程池来异步执行打印语句。

  3. public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
    这个方法接受一个Supplier对象作为参数，用于异步执行一个有返回值的任务。同样，该方法也会使用ForkJoinPool.commonPool()作为默认的线程池来执行任务。例如：

    CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    return computeExpensiveResult();
});

    上面的代码会异步计算一个昂贵的结果，并返回一个CompletableFuture对象，可以通过future.get()方法获取结果。

  4. public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)
    这个方法与上一个方法类似，但允许用户自定义线程池来执行任务。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    return computeExpensiveResult();
}, executor);

    上面的代码会使用一个包含5个线程的固定线程池来异步计算一个昂贵的结果，并返回一个CompletableFuture对象。

三，编排1：获取异步任务结果和处理异常

  • whenComplete 获取结果，可以感知异常
  • exceptionally处理异常，并设置默认值
package com.atguigu.gulimall.search.threads;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadTest {

    public static void main(String[] args) {

        ExecutorService executorService = Executors.newFixedThreadPool(10);
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            int i = 100/0;
            return 10;
        }, executorService);

        // 获取结果，根据是否有隐藏做不桶处理，不能设置默认值
        CompletableFuture<Integer> completableFuture1 = completableFuture.whenComplete((res, exc) -> {
            if (exc != null) {
                System.out.println("有异常+" + exc);
            }
            System.out.println("异步任务的结果是" + res);
        });
        
        // 有异常会回调，可以设置默认值
        CompletableFuture<Integer> completableFuture2 = completableFuture1.exceptionally((ex) -> {
            System.out.println("有异常+" + ex);
            return 100;
        });

        completableFuture2.whenComplete((res, exc)->{
            System.out.println("res="+res);
        });
    }
}

四，编排2：多线程串行

图中展示的是Java 8中CompletableFuture类的一些常用方法，主要用于链式处理异步任务。这些方法分为三组：

  • thenApply系列方法，有返回值
  • thenRun系列方法，无返回值，不能拿到上一步的结果
  • thenAccept系列方法，无返回值，可以拿到上一步的结果

1. thenApply系列方法：

  • thenApply(Function<? super T, ? extends U> fn)：这个方法接收一个Function对象作为参数，用于转换当前CompletableFuture的结果。当当前CompletableFuture完成后，会应用传入的函数并将结果传递给下一个CompletableFuture。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = future1.thenApply(String::length);

    在上面的例子中，future1是一个已完成的CompletableFuture，它的结果是字符串"Hello"。future2是future1的一个后续操作，它会计算字符串的长度。

  • thenApplyAsync(Function<? super T, ? extends U> fn)：这个方法与thenApply类似，不同之处在于它是异步执行的。也就是说，转换操作不会阻塞当前线程，而是由另一个线程来执行。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = future1.thenApplyAsync(String::length);

    在上面的例子中，future2的转换操作是由另一个线程异步执行的。

  • thenApplyAsync(Function<? super T, ? extends U> fn, Executor executor)：这个方法与thenApplyAsync类似，但它允许用户自定义线程池来执行转换操作。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = future1.thenApplyAsync(String::length, executor);

    在上面的例子中，future2的转换操作是由一个包含5个线程的固定线程池来异步执行的。

2. thenAccept系列方法：

  • thenAccept(Consumer<? super T> action)：这个方法接收一个Consumer对象作为参数，用于消费当前CompletableFuture的结果。当当前CompletableFuture完成后，会应用传入的操作，但不返回任何结果。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
future1.thenAccept(System.out::println);

    在上面的例子中，future1的结果会被打印出来。

  • thenAcceptAsync(Consumer<? super T> action)：这个方法与thenAccept类似，不同之处在于它是异步执行的。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
future1.thenAcceptAsync(System.out::println);

    在上面的例子中，打印操作是由另一个线程异步执行的。

  • thenAcceptAsync(Consumer<? super T> action, Executor executor)：这个方法与thenAcceptAsync类似，但它允许用户自定义线程池来执行消费操作。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
future1.thenAcceptAsync(System.out::println, executor);

    在上面的例子中，打印操作是由一个包含5个线程的固定线程池来异步执行的。

3. thenRun系列方法：

  • thenRun(Runnable action)：这个方法接收一个Runnable对象作为参数，在当前CompletableFuture完成后执行。它不依赖于当前CompletableFuture的结果，只是简单地执行后续操作。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
future1.thenRun(() -> System.out.println("Task completed"));

    在上面的例子中，无论future1的结果是什么，都会输出"Task completed"。

  • thenRunAsync(Runnable action)：这个方法与thenRun类似，不同之处在于它是异步执行的。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
future1.thenRunAsync(() -> System.out.println("Task completed"));

    在上面的例子中，后续操作是由另一个线程异步执行的。

  • thenRunAsync(Runnable action, Executor executor)：这个方法与thenRunAsync类似，但它允许用户自定义线程池来执行后续操作。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
future1.thenRunAsync(() -> System.out.println("Task completed"), executor);

    在上面的例子中，后续操作是由一个包含5个线程的固定线程池来异步执行的。

五，编排3：两个异步任务组合为一个任务

把两个任务组合为一个任务，只有两个任务都完成了，才会执行后续任务。

1. thenCombine系列方法

  • thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)：这个方法用于组合两个CompletableFuture，当这两个CompletableFuture都完成后，会应用传入的BiFunction对象并将结果传递给一个新的CompletableFuture。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
CompletableFuture<String> combined = future1.thenCombine(future2, (s, i) -> s + " " + i);

    在上面的例子中，combined是一个新的CompletableFuture，它会等待future1和future2都完成后，将它们的结果合并成一个字符串。

  • thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)：这个方法与thenCombine类似，不同之处在于它是异步执行的。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
CompletableFuture<String> combined = future1.thenCombineAsync(future2, (s, i) -> s + " " + i);

    在上面的例子中，合并操作是由另一个线程异步执行的。

  • thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn, Executor executor)：这个方法与thenCombineAsync类似，但它允许用户自定义线程池来执行合并操作。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
CompletableFuture<String> combined = future1.thenCombineAsync(future2, (s, i) -> s + " " + i, executor);

    在上面的例子中，合并操作是由一个包含5个线程的固定线程池来异步执行的。

2. thenAcceptBoth系列方法

  • thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)：这个方法用于组合两个CompletableFuture，当这两个CompletableFuture都完成后，会应用传入的BiConsumer对象来消费它们的结果。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
future1.thenAcceptBoth(future2, (s, i) -> System.out.println(s + " " + i));

    在上面的例子中，当future1和future2都完成后，会打印出它们的结果。

  • thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)：这个方法与thenAcceptBoth类似，不同之处在于它是异步执行的。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
future1.thenAcceptBothAsync(future2, (s, i) -> System.out.println(s + " " + i));

    在上面的例子中，消费操作是由另一个线程异步执行的。

  • thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action, Executor executor)：这个方法与thenAcceptBothAsync类似，但它允许用户自定义线程池来执行消费操作。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
future1.thenAcceptBothAsync(future2, (s, i) -> System.out.println(s + " " + i), executor);

    在上面的例子中，消费操作是由一个包含5个线程的固定线程池来异步执行的。

3. runAfterBoth系列方法

  • runAfterBoth(CompletionStage<?> other, Runnable action)：这个方法用于组合两个CompletableFuture，当这两个CompletableFuture都完成后，会执行传入的Runnable对象。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
future1.runAfterBoth(future2, () -> System.out.println("Both tasks completed"));

    在上面的例子中，当future1和future2都完成后，会输出"Both tasks completed"。

  • runAfterBothAsync(CompletionStage<?> other, Runnable action)：这个方法与runAfterBoth类似，不同之处在于它是异步执行的。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
future1.runAfterBothAsync(future2, () -> System.out.println("Both tasks completed"));

    在上面的例子中，后续操作是由另一个线程异步执行的。

  • runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor)：这个方法与runAfterBothAsync类似，但它允许用户自定义线程池来执行后续操作。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
future1.runAfterBothAsync(future2, () -> System.out.println("Both tasks completed"), executor);

    在上面的例子中，后续操作是由一个包含5个线程的固定线程池来异步执行的。

五，编排4：2个完成一个即可

CompletableFuture类的另外三个方法，它们用于处理两个CompletableFuture中的任意一个完成的情况。这些方法可以帮助我们在两个异步任务中选择一个先完成的任务进行后续处理。下面逐一解释它们的使用和区别：

1，applyToEither系列方法

  • applyToEither(CompletionStage<? extends U> other, Function<? super U, V> fn)：这个方法用于在两个CompletableFuture中选择第一个完成的任务，然后应用传入的Function对象并返回一个新的CompletableFuture。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5).thenDelay(1000, TimeUnit.MILLISECONDS);
CompletableFuture<String> either = future1.applyToEither(future2, String::valueOf);

    在上面的例子中，either是一个新的CompletableFuture，它会选择首先完成的任务（在这个例子中是future1），并将其结果转换为字符串。

  • applyToEitherAsync(CompletionStage<? extends U> other, Function<? super U, V> fn)：这个方法与applyToEither类似，不同之处在于它是异步执行的。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5).thenDelay(1000, TimeUnit.MILLISECONDS);
CompletableFuture<String> either = future1.applyToEitherAsync(future2, String::valueOf);

    在上面的例子中，转换操作是由另一个线程异步执行的。

  • applyToEitherAsync(CompletionStage<? extends U> other, Function<? super U, V> fn, Executor executor)：这个方法与applyToEitherAsync类似，但它允许用户自定义线程池来执行转换操作。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5).thenDelay(1000, TimeUnit.MILLISECONDS);
CompletableFuture<String> either = future1.applyToEitherAsync(future2, String::valueOf, executor);

    在上面的例子中，转换操作是由一个包含5个线程的固定线程池来异步执行的。

2. acceptEither系列方法

  • acceptEither(CompletionStage<? extends U> other, Consumer<? super U> action)：这个方法用于在两个CompletableFuture中选择第一个完成的任务，然后应用传入的Consumer对象来消费其结果。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5).thenDelay(1000, TimeUnit.MILLISECONDS);
future1.acceptEither(future2, System.out::println);

    在上面的例子中，当其中一个任务完成时，会打印出其结果。

  • acceptEitherAsync(CompletionStage<? extends U> other, Consumer<? super U> action)：这个方法与acceptEither类似，不同之处在于它是异步执行的。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5).thenDelay(1000, TimeUnit.MILLISECONDS);
future1.acceptEitherAsync(future2, System.out::println);

    在上面的例子中，消费操作是由另一个线程异步执行的。

  • acceptEitherAsync(CompletionStage<? extends U> other, Consumer<? super U> action, Executor executor)：这个方法与acceptEitherAsync类似，但它允许用户自定义线程池来执行消费操作。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5).thenDelay(1000, TimeUnit.MILLISECONDS);
future1.acceptEitherAsync(future2, System.out::println, executor);

    在上面的例子中，消费操作是由一个包含5个线程的固定线程池来异步执行的。

3. runAfterEither系列方法

  • runAfterEither(CompletionStage<?> other, Runnable action)：这个方法用于在两个CompletableFuture中选择第一个完成的任务，然后执行传入的Runnable对象。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5).thenDelay(1000, TimeUnit.MILLISECONDS);
future1.runAfterEither(future2, () -> System.out.println("One of the tasks completed"));

    在上面的例子中，当其中一个任务完成时，会输出"One of the tasks completed"。

  • runAfterEitherAsync(CompletionStage<?> other, Runnable action)：这个方法与runAfterEither类似，不同之处在于它是异步执行的。例如：

    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5).thenDelay(1000, TimeUnit.MILLISECONDS);
future1.runAfterEitherAsync(future2, () -> System.out.println("One of the tasks completed"));

    在上面的例子中，后续操作是由另一个线程异步执行的。

  • runAfterEitherAsync(CompletionStage<?> other, Runnable action, Executor executor)：这个方法与runAfterEitherAsync类似，但它允许用户自定义线程池来执行后续操作。例如：

    ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5).thenDelay(1000, TimeUnit.MILLISECONDS);
future1.runAfterEitherAsync(future2, () -> System.out.println("One of the tasks completed"), executor);

    在上面的例子中，后续操作是由一个包含5个线程的固定线程池来异步执行的。

六，编排5：编排多个任务

1. allOf()方法：多个任务全部完成才行

  • public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)：这个方法用于创建一个新的CompletableFuture，表示所有输入的CompletableFuture都已完成。例如：
    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
CompletableFuture<Void> all = CompletableFuture.allOf(future1, future2);
all.get()；
    在上面的例子中，all是一个新的CompletableFuture，它会在future1和future2都完成后才完成。

当所有的CompletableFuture都完成后，可以通过all.join()或者all.get()获取结果。由于all本身没有结果，所以它的类型是Void。如果任何一个CompletableFuture失败了，那么all也会立即失败，并抛出相应的异常。

2. anyOf()方法：一个任务完成即可

  • public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)：这个方法用于创建一个新的CompletableFuture，表示至少有一个输入的CompletableFuture已经完成。例如：
    CompletableFuture<String> future1 = CompletableFuture.completedFuture("Hello");
CompletableFuture<Integer> future2 = CompletableFuture.completedFuture(5);
CompletableFuture<Object> any = CompletableFuture.anyOf(future1, future2);
    在上面的例子中，any是一个新的CompletableFuture，它会在future1或future2中任一完成时就完成。

当至少有一个CompletableFuture完成时，可以通过any.join()或者any.get()获取结果。由于any可能由任何CompletableFuture的结果决定，所以它的类型是Object。如果所有的CompletableFuture都失败了，那么any也会失败，并抛出最后一个发生的异常。

小手追梦
关注
专栏目录
全网最全-谷粒商城项目-面试总结-简历优化
成功最快的秘诀: 抱团取暖 。
09-20 28万+
该系用采用SpringCloud架构，利用SpringBoot构建应用，利用Nacos作为服务的注册、配置中心，利用OpenFeign实现与其他模块进行交互，利用Sentinel实现熔断降级和错误处理，利用Gateway作为服务网关，利用RabbitMQ实现延迟队列，利用Redis作为缓存解决读多写少的场景，利用MySQL进行持久化，利用MyBatisPlus作为持久化框架。
线程池加异步编排
weixin_45762031的博客
12-13 4333
线程回顾 初始化线程的4种方式： 继承Thread 实现Runnable接口 实现Callable接口 + FutureTask （可以拿到返回结果，可以处理异常） 线程池 方式1和方式2：主进程无法获取线程的运算结果。不适合当前场景 方式3：主进程可以获取线程的运算结果，并设置给itemVO，但是不利于控制服务器中的线程资源。可以导致服务器资源耗尽。 方式4：通过如下两种方式初始化线程池...
Day419.CompletableFuture 异步编排 -谷粒商城
阿昌爱Java
10-14 718
CompletableFuture 异步编排 阿昌总结今天学习到的CompletableFuture 当我们在异步任务编程的时候，可能会有场景如下： 可能你会想到用之前我们学到的Callable的方式去获取结果后，再执行； 但是这样子不能保证是异步与异步之间的结果； C不能感知到AB的结果后再异步执行； 所以，这里我们就引出了 CompletableFuture 一、前言 什么是CompletableFuture呢？ CompletableFuture 和 FutureTask 同属于 Future 接口
22-09-23 西安 谷粒商城（05）CompletableFuture异步编排、nginx实现页面静态化
m0_56799642的博客
09-23 1054
java8提供了基于FutureTask+Callable封装的一个类：CompletableFuture，可以直接执行异步任务并获取任务的结果，同时还可以将多个有任务前后依赖关系的任务使用队列按顺序执行CompletableFuture 实现了Future接口，可以获取任务执行的结果 或者任务执行的状态CompletableFuture 实现了 CompletionStage接口，可以对多个任务进行编排，控制任务按什么顺序执行 1、初始化执行异步任务 CompletableFuture 提供了四个
谷粒商城十五商品详情CompletableFuture异步编排
梦想是很难很难的，所以先勇敢一点
02-25 2525
例如a,b,c三个异步任务，不是随机运行就可以，它们还有一定的关系，c需要等待a的返回结果，b不需要等待谁的结果。当异步任务产生一些关系和顺序之后，我们要编排好它们的关系进行调用，又是一个复杂的过程。我们可以用来解决这个问题。
197、商城业务-异步-CompletableFuture-完成回调与异常感知
pyd1040201698的博客
09-06 298
public static void main(String[] args) throws ExecutionException, InterruptedException { System.out.println("main....start....."); // CompletableFuture<Void> future = CompletableFuture.runAsync(() -> { // System.out.p...
谷粒商城实战笔记-260-商城业务-消息队列-可靠投递-消费端确认
epitomizelu的专栏
08-26 800
消费者端的确认机制（ACK/NACK）是RabbitMQ中一种重要的特性，它允许消费者告知Broker它们是否成功处理了接收到的消息。basic.ack：当消费者成功处理了一条消息时，它可以发送一个basic.ack（肯定确认）给Broker，指示这条消息可以安全删除。// deliveryTag是消息的唯一标识符，multiple参数设为false表示仅确认这一条消息如果消费者无法处理消息，它可以发送一个basic.nack（否定确认）。这可以让Broker重新分发消息，或者直接丢弃它。
软件资源-谷粒商城资料
08-04
软件资源----谷粒商城资料
全网最全-谷粒商城项目-面试总结-简历优化_Java-You的博客-CSDN博客 .html
03-09
全网最全-谷粒商城项目-面试总结-简历优化_Java-You的博客-CSDN博客 .html
二、谷粒商城- 快速开发之逆向工程使用（2）gulimall源码&生成器及生成的源码.zip
最新发布
09-18
二、谷粒商城- 快速开发之逆向工程使用（2）gulimall源码&生成器及生成的源码.zip
结合电商模式打造校园交易平台之CompletableFuture异步编程篇（全文总共13万字，超详细）
xjx666666的博客
02-17 562
首先我们回顾一下初始化线程的四种方式：1和2：主进程无法获取线程的运算结果3：主进程可以获取当前线程的运算结果，但是不利于控制服务器种的线程资源，可能导致服务器资源耗尽4：线程池执行异步任务性能稳定，也可以选择获取执行结果（可以不获取）并捕获异常。但是，在业务复杂情况下，一个异步调用可能会依赖于另一个异步调用的执行结果。可以通过如下两种方式初始化线程池 四种方式代码如下： 线程池 我们以后在实际业务中前三种启动线程的方式都不用，我们将所有的多线程异步任务都交给线程池执行。线程池(ThreadPoolExec
谷粒商城学习笔记（12.商城业务-商品详情（异步&&线程））
Kiritoasu的博客
09-21 280
本章主要完成商城商品详情页面的查询编写，同时涉及异步线程池知识，运用异步查询商品的各类信息。
200、商城业务-异步-CompletableFuture-两任务组合-都要完成
pyd1040201698的博客
09-07 411
/** * 两个都完成 */ CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> { System.out.println("任务1线程：" + Thread.currentThread().getId()); int i = 10 / 2; Syste...
CompletableFuture的使用
有料，有味，很重要
06-16 7122
CompletableFuture解决的问题: 总的来说，就是 解决future模式的缺点。主要是 a. 为了解决Future虽然可以实现异步获取线程的执行结果，但是future没有提供通知机制，调用方无法得知future什么时候执行完的问题。 b.要么使用阻塞， 在future.get()的地方等待future返回结果，这时会变成同步操作。如果使用isDone()方法进行循环判断，就会消耗...
学习笔记JVM篇（五）
仔哥学编程
09-17 608
代码解析：首先根据处理器数量来确定创建的线程数量，然后创建线程不断的死循环执行一些逻辑，这样可以让CPU寻思飙高。JPS全称 Java Process Status Tool，这个命令与Liunx的PS很像，下面我们测试一下这个命令，首先编写一段非常简单的Java代码。jstack是java栈的跟踪器，可以打印出java应用程序中所有线程的信息、包含堆栈信息、调用栈信息、锁等信息，所以常用于诊断死锁、内存泄漏等等。使用JPS命令，可以看到我们刚才启动的Java进程，同时进程号为7484。
shader 案例学习笔记之将坐标系分成4个象限
localhost
09-13 237
坐标系被分成了4个单元格，每个单元格都有唯一的索引，后续就可以根据索引去渲染。
arm和riscv系统调用对比(笔记)
maosql
09-13 621
相似之处: ecall 和 SVC 都是用于从用户模式切换到内核模式，执行系统调用。它们的作用和使用方式非常相似，都是触发内核级别的处理，以处理用户请求的特权操作。不同之处: PendSV 是一个用于任务切换的中断机制，与 ecall 和 SVC 的作用不同。PendSV 主要用于上下文切换，而 ecall 和 SVC 是用于请求系统服务的机制。
ROS组合导航笔记1：融合传感器数据
qq_44188415的博客
09-16 623
笔记
从前慢-谷粒商城篇章
08-17
引用引用引用<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [从前慢-谷粒商城篇章4](https://blog.csdn.net/unique_perfect/article/details/114685933)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [2020年谷粒商城md笔记](https://download.csdn.net/download/ZHUXIUQINGIT/12543161)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小手追梦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值