CompletableFuture探秘：解锁Java并发编程的新境界

置顶 已于 2023-12-15 16:44:21 修改
阅读量1.3w 收藏 14
点赞数 17
分类专栏： java 文章标签： java 开发语言 Future
于 2023-11-29 17:35:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mrxiao_bo/article/details/134695428
版权

欢迎来到我的博客，代码的世界里，每一行都是一个故事


在这里插入图片描述

CompletableFuture探秘：解锁Java并发编程的新境界

前言

在Java的世界中，异步编程是应对高并发的利器，而CompletableFuture则是这个工具箱中的瑰宝。就像是一把打开未来之门的钥匙，CompletableFuture为我们提供了更高效、更灵活的并发编程方式。让我们一同踏上这段深入CompletableFuture的实战之旅，发现异步编程的魔力。

第一：CompletableFuture的基础概念

CompletableFuture 是 Java 平台提供的一个强大的异步编程工具，用于处理异步操作和构建非阻塞的异步应用程序。下面是一些基本概念和它与传统 Future 的区别和优势：

CompletableFuture 的基本概念：

  1. 异步操作： CompletableFuture 允许你执行异步操作，即在后台线程中执行某些任务，而不阻塞主线程。

  2. 组合操作： 你可以将多个 CompletableFuture 实例组合在一起，以便在一个或多个完成时执行进一步的操作。

  3. 异常处理： CompletableFuture 提供了更强大的异常处理机制，可以方便地处理异步操作中的异常。

  4. 回调函数： 你可以使用回调函数来处理异步操作的结果，而不必等待操作完成。

与传统 Future 的区别和优势：

  1. 可编程性： CompletableFuture 提供了更灵活的编程模型，使得异步操作的组合和串联更为容易。

  2. 组合操作： 通过方法链（method chaining）的方式，你可以轻松地组合多个异步操作，而不需要复杂的嵌套结构。

  3. 异常处理： CompletableFuture 允许你对异常进行更细粒度的控制，可以在异常发生时执行特定的操作。

  4. 可观察性： 你可以轻松地监视异步操作的状态，了解它们何时完成，以及它们的结果是成功还是失败。

  5. 非阻塞： CompletableFuture 的设计使得异步操作可以在后台线程中执行，不会阻塞主线程的执行。

下面是一个简单的例子，演示了如何使用 CompletableFuture 进行异步操作：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 异步执行任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello, ")
                .thenApplyAsync(result -> result + "world!")
                .thenAcceptAsync(System.out::println);

        // 阻塞主线程，等待异步操作完成
        future.join();
    }
}

在这个例子中，我们首先使用 supplyAsync 方法异步地生成一个字符串，然后使用 thenApplyAsync 进一步处理该字符串，最后使用 thenAcceptAsync 打印结果。这是一个简单的异步操作链。

第二：异步任务的创建与执行

当涉及到创建和执行异步任务时，CompletableFuture 提供了两个主要的静态方法：supplyAsync 和 runAsync。这两个方法都可以用于启动异步任务。下面是一个演示如何使用这些方法的例子：

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

public class AsyncTasksExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 使用 supplyAsync 创建一个异步任务，该任务产生一个字符串结果
        CompletableFuture<String> supplyAsyncFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("Running supplyAsync task on thread: " + Thread.currentThread().getName());
            return "Hello, ";
        });

        // 使用 runAsync 创建一个异步任务，该任务执行一个无返回值的操作
        CompletableFuture<Void> runAsyncFuture = CompletableFuture.runAsync(() -> {
            System.out.println("Running runAsync task on thread: " + Thread.currentThread().getName());
            System.out.println("Doing some asynchronous work.");
        });

        // 等待 supplyAsync 任务完成并获取结果
        String supplyAsyncResult = supplyAsyncFuture.get();
        System.out.println("Result of supplyAsync task: " + supplyAsyncResult);

        // 等待 runAsync 任务完成
        runAsyncFuture.get();
        System.out.println("runAsync task completed.");

        // 注意：在实际应用中，你可能会在异步任务完成时执行更复杂的操作，而不仅仅是调用 get() 方法。

        // 关闭 CompletableFuture 默认使用的 ForkJoinPool，以确保程序正常退出
        CompletableFuture<Void> shutdownFuture = CompletableFuture.runAsync(() -> CompletableFuture.delayedExecutor(1, java.util.concurrent.TimeUnit.SECONDS));
        shutdownFuture.get(); // 阻塞等待关闭完成
    }
}

在这个例子中，我们使用了 supplyAsync 创建了一个返回字符串的异步任务，以及 runAsync 创建了一个没有返回值的异步任务。在实际应用中，异步任务可能会执行一些耗时的操作，例如访问数据库、调用远程服务等。在任务完成后，可以使用 get 方法来获取异步任务的结果，或者执行其他操作。

第三：CompletableFuture的组合与转换

CompletableFuture 提供了丰富的方法，使得你可以轻松地组合和转换异步任务。以下是一些详细的示例，演示了如何使用 thenCombine、thenCompose 等方法进行链式操作：

1. thenCombine 方法

thenCombine 方法允许你在两个 CompletableFuture 完成时执行一个操作，并使用两个任务的结果进行计算。下面是一个例子：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureCombinationExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "world");

        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + ", " + result2);

        // 等待组合任务完成并获取结果
        String combinedResult = combinedFuture.join();
        System.out.println(combinedResult);
    }
}

在这个例子中，future1 和 future2 分别产生 “Hello” 和 “world”，然后通过 thenCombine 方法将它们组合在一起，使用lambda表达式将它们连接成一个字符串。

2. thenCompose 方法

thenCompose 方法允许你在一个 CompletableFuture 完成后，将其结果传递给一个函数，并返回一个新的 CompletableFuture。这是一个典型的用法，当你有一个异步任务的结果是另一个异步任务的输入时，可以使用 thenCompose。下面是一个例子：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureCompositionExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
        
        CompletableFuture<String> composedFuture = future1.thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " world"));

        // 等待组合任务完成并获取结果
        String composedResult = composedFuture.join();
        System.out.println(composedResult);
    }
}

在这个例子中，future1 生成 “Hello”，然后通过 thenCompose 方法将其结果传递给一个函数，该函数返回一个新的 CompletableFuture，生成 “Hello world”。

这些方法的灵活性使得你能够以清晰、组织良好的方式组合和转换异步任务的结果。

第四：异常处理与超时控制

CompletableFuture 提供了强大的异常处理机制，同时也支持设置异步任务的超时时间。以下是详细的示例，演示了如何处理异常并设置超时：

1. 异常处理

CompletableFuture 允许你使用 exceptionally 方法来处理异步任务中发生的异常。下面是一个例子：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExceptionHandlingExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一个可能抛出异常的操作
            if (Math.random() < 0.5) {
                throw new RuntimeException("Oops, something went wrong!");
            }
            return "Hello";
        });

        // 使用 exceptionally 处理异常
        CompletableFuture<String> exceptionHandledFuture = future.exceptionally(ex -> {
            System.err.println("Exception occurred: " + ex.getMessage());
            return "Default Value"; // 提供默认值
        });

        // 等待任务完成并获取结果
        String result = exceptionHandledFuture.join();
        System.out.println("Result: " + result);
    }
}

在这个例子中，supplyAsync 方法模拟了一个可能抛出异常的操作，然后通过 exceptionally 方法处理异常，提供了一个默认值。你可以根据具体需求进行更复杂的异常处理。

2. 超时控制

CompletableFuture 提供了 completeOnTimeout 方法，允许你在指定的超时时间内完成任务，否则使用默认值。下面是一个例子：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class CompletableFutureTimeoutExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一个长时间运行的操作
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        });

        // 设置超时时间为2秒，并在超时时使用默认值
        CompletableFuture<String> timeoutFuture = future.completeOnTimeout("Default Value", 2, TimeUnit.SECONDS);

        // 等待任务完成并获取结果
        String result = timeoutFuture.join();
        System.out.println("Result: " + result);
    }
}

在这个例子中，supplyAsync 方法模拟了一个长时间运行的操作，然后通过 completeOnTimeout 方法设置了超时时间为2秒，并提供了一个默认值。如果异步任务在超时时间内未完成，将使用默认值。

这些方法为你提供了在异步编程中处理异常和控制超时的灵活性。

第五：CompletableFuture的并发与合并

CompletableFuture 提供了丰富的方法，可以用于执行并发操作并将多个任务的结果进行合并。以下是一些详细的示例，演示如何利用 CompletableFuture 进行并发操作，并使用 allOf、anyOf 等方法进行结果的合并：

1. 并发操作

使用 CompletableFuture.allOf 方法可以并行执行多个任务，等待它们全部完成。下面是一个例子：

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

public class CompletableFutureConcurrentExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Result from Task 1");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Result from Task 2");
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "Result from Task 3");

        // 并行执行多个任务
        CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2, future3);

        // 等待所有任务完成
        allOfFuture.get();

        // 获取各个任务的结果
        String result1 = future1.join();
        String result2 = future2.join();
        String result3 = future3.join();

        System.out.println("Result 1: " + result1);
        System.out.println("Result 2: " + result2);
        System.out.println("Result 3: " + result3);
    }
}

在这个例子中，allOf 方法用于并行执行三个任务，并等待它们全部完成。然后，通过 join 方法获取各个任务的结果。

2. 合并结果

CompletableFuture.anyOf 方法用于获取多个任务中任意一个完成的结果。下面是一个例子：

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

public class CompletableFutureCombiningExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Result from Task 1");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Result from Task 2");
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "Result from Task 3");

        // 获取任意一个任务完成的结果
        CompletableFuture<Object> anyOfFuture = CompletableFuture.anyOf(future1, future2, future3);

        // 等待任意一个任务完成
        Object result = anyOfFuture.get();

        System.out.println("Result from any task: " + result);
    }
}

在这个例子中，anyOf 方法用于获取三个任务中任意一个任务完成的结果。然后，通过 get 方法获取结果。

这些方法使得你可以方便地执行并发操作，并根据需要合并多个任务的结果。

第六：异步编程的最佳实践

异步编程是一种强大的技术，但也容易引入一些陷阱和错误。以下是一些异步编程的最佳实践以及如何避免常见的问题：

最佳实践：

  1. 使用CompletableFuture的工厂方法： CompletableFuture 提供了多个工厂方法，如 supplyAsync 和 runAsync，这些方法可以方便地创建异步任务。

  2. 链式操作： 利用 thenApply, thenCompose 和 thenAccept 等方法进行链式操作，以构建清晰的异步任务链。

  3. 异常处理： 使用 exceptionally 处理异步任务中的异常，确保你的程序能够优雅地处理错误情况。

  4. 超时控制： 使用 completeOnTimeout 或者 orTimeout 方法设置异步任务的超时时间，避免无限期等待任务完成。

  5. 并发操作： 使用 allOf 和 anyOf 等方法并行执行多个任务，以提高系统的并发性能。

  6. 线程池管理： 在 supplyAsync 和 runAsync 等方法中使用自定义的 Executor 来控制线程池，以防止意外地使用默认的公共线程池。

  7. 避免阻塞： 尽量避免在异步任务中使用阻塞操作，因为这会降低异步性能。如果需要阻塞操作，考虑使用异步 API 或者将其委托给另一个线程。

常见陷阱和错误：

  1. 忘记等待任务完成： 在异步编程中，确保在需要结果的地方等待任务完成，避免直接调用 join 或 get 方法以外的其他操作。

  2. 不正确的异常处理： 异步任务中的异常可能会被吞噬，确保正确使用 exceptionally 处理异常，以及在合适的地方进行日志记录。

  3. 忽略线程安全： 如果多个异步任务访问共享状态，确保进行适当的同步，以避免线程安全问题。

  4. 过度使用并行操作： 并不是所有的任务都适合并行执行。一些任务可能会受到共享资源的限制，或者因为并行而导致性能下降。

  5. 忽略取消和中断： 如果异步任务可以被取消，确保实现了适当的取消机制。此外，考虑线程中断的情况，以便能够响应中断请求。

  6. 不适当的线程池使用： 默认情况下，CompletableFuture 使用的是公共的 ForkJoinPool，可能导致线程争用。根据需要，使用自定义的线程池进行任务调度。

  7. 不注意资源泄漏： 在使用异步编程时，确保关闭不再需要的资源，防止资源泄漏。

遵循这些最佳实践并注意避免常见的陷阱和错误，可以帮助你更有效地利用异步编程的优势。

第七：CompletableFuture与回调机制

CompletableFuture 通过 thenApply, thenCompose, handle 等方法提供了回调机制，使你能够在异步任务完成时执行特定的操作。以下是一些演示如何使用回调机制的例子：

1. 使用 thenApply 处理异步任务的结果

import java.util.concurrent.CompletableFuture;

public class CompletableFutureCallbackExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");

        // 使用 thenApply 处理异步任务的结果，并返回一个新的 CompletableFuture
        CompletableFuture<String> callbackFuture = future.thenApply(result -> result + " world");

        // 注册回调函数，在结果准备好时执行
        callbackFuture.thenAccept(finalResult -> System.out.println("Callback Result: " + finalResult));

        // 等待异步任务完成
        future.join();
    }
}

在这个例子中，thenApply 方法用于在异步任务完成时对结果进行处理，并返回一个新的 CompletableFuture。然后，通过 thenAccept 注册回调函数，在结果准备好时执行。

2. 使用 handle 处理结果或异常

import java.util.concurrent.CompletableFuture;

public class CompletableFutureHandleExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一个可能抛出异常的操作
            if (Math.random() < 0.5) {
                throw new RuntimeException("Oops, something went wrong!");
            }
            return "Hello";
        });

        // 使用 handle 处理异步任务的结果或异常
        CompletableFuture<String> handleFuture = future.handle((result, exception) -> {
            if (exception != null) {
                System.err.println("Exception occurred: " + exception.getMessage());
                return "Default Value"; // 提供默认值
            } else {
                return result + " world";
            }
        });

        // 注册回调函数，在结果准备好时执行
        handleFuture.thenAccept(finalResult -> System.out.println("Handle Result: " + finalResult));

        // 等待异步任务完成
        future.join();
    }
}

在这个例子中，handle 方法用于处理异步任务的结果或异常。回调函数接收两个参数：任务的结果和可能的异常。通过检查异常，你可以决定如何处理结果或提供默认值。

通过这些方法，你可以灵活地处理异步任务的结果和异常，从而实现回调机制。

第八：性能优化与调优

性能优化和调优在异步编程中至关重要，尤其是在高负载环境中。以下是一些建议和技巧，帮助你优化 CompletableFuture 的性能：

1. 合理使用线程池

  • 指定自定义线程池： 默认情况下，CompletableFuture 使用公共的 ForkJoinPool。在高负载环境中，考虑创建自定义的线程池，并在异步任务中指定该线程池，以防止与其他任务争用线程资源。
Executor customExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello", customExecutor);
  • 合理调整线程池大小： 根据应用的负载和硬件配置，调整线程池的大小以达到最佳性能。使用过大的线程池可能会导致资源浪费，而使用过小的线程池可能导致性能下降。

2. 避免阻塞操作

  • 使用异步 API： 尽量避免在异步任务中使用同步的、阻塞的 API。如果必须使用阻塞操作，考虑将其委托给另一个线程，以防止阻塞主线程。
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
 // 避免在此处使用阻塞操作
 doSomeNonBlockingWork();
});

3. 批处理和并发操作

  • 批处理： 将相关的任务分组并批量处理，以减少线程切换的开销。
List<CompletableFuture<String>> futures = new ArrayList<>();
for (int i = 0; i < 10; i++) {
 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Task " + i);
 futures.add(future);
}
CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
  • 并发操作： 使用 allOf 和 anyOf 等方法，以提高系统的并发性能。

4. 调整超时时间

  • 设置合理的超时时间： 使用 completeOnTimeout 或者 orTimeout 方法设置异步任务的超时时间，以避免任务过长的等待时间。
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
 // 长时间运行的操作
 return "Result";
});
CompletableFuture<String> timeoutFuture = future.completeOnTimeout("Default Result", 5, TimeUnit.SECONDS);

5. 内存管理

  • 避免内存泄漏： 在异步编程中，确保及时关闭不再需要的资源，以避免内存泄漏。

6. 监控和调试

  • 使用监控工具： 利用性能监控工具（例如 VisualVM、JProfiler 等）来分析应用程序的异步任务执行情况，并找出性能瓶颈。

  • 日志记录： 在异步任务中适当记录日志，以便跟踪任务的执行流程和性能信息。

这些技巧可以帮助你优化 CompletableFuture 的性能，并在高负载环境中获得更好的性能表现。根据具体情况，可能需要进行更深入的性能分析和调优。

第九：Java中的其他并发工具与CompletableFuture的比较

在 Java 中，有许多并发工具可用，包括 Executor 框架、ForkJoin 框架等。以下是 CompletableFuture 与其他并发工具的比较，以及在何种情况下选择使用 CompletableFuture 的一些建议：

1. Executor 框

  • CompletableFuture 优势：

    • CompletableFuture 是基于 Executor 的，但它提供了更高级别的抽象，允许你更方便地进行异步编程。
    • CompletableFuture 允许你通过方法链（method chaining）的方式组合多个异步任务，更容易构建异步任务链。

  • 选择情景：

    • 如果只需要简单的异步执行，且不需要多个异步任务之间的复杂关系，使用 Executor 可能更为直观和轻量。

2. ForkJoin 框

  • CompletableFuture 优势：

    • CompletableFuture 可以与 ForkJoinPool 集成，允许你更灵活地进行并行操作。
    • 通过 allOf 和 anyOf 方法，CompletableFuture 提供了更方便的并发操作方法。

  • 选择情景：

    • 如果问题可以通过任务分割和递归的方式解决，并且你需要更细粒度的并行操作，那么 ForkJoin 框架可能更适合。
    • 如果你更关心异步任务的组合和链式操作，或者需要更高级别的异常处理和超时控制，那么选择 CompletableFuture 更为合适。

3. 选择 CompletableFuture 的情景

  • 组合和链式操作： 当你需要执行复杂的异步操作链时，CompletableFuture 提供了更灵活的方法，能够方便地组合和链式调用异步任务。

  • 异常处理和超时控制： CompletableFuture 提供了更丰富的异常处理机制和超时控制，使得你能够更好地处理异步任务中可能出现的问题。

  • 更高级别的抽象： 如果你希望在异步任务中使用更高级别的抽象，例如回调函数、条件判断等，CompletableFuture 提供了更多的便利。

  • 并发和并行操作： 对于需要并发执行多个任务或并行操作的场景，CompletableFuture 提供了 allOf 和 anyOf 等方法，使得并发操作更为容易。

总体而言，CompletableFuture 在处理异步编程时提供了更高级别、更灵活的抽象，适用于复杂的异步场景。选择 CompletableFuture 的主要考虑因素包括异步任务的组合性质、对异常的处理需求、以及是否需要更高级别的并发控制。

结语

深深感谢你阅读完整篇文章，希望你从中获得了些许收获。如果觉得有价值，欢迎点赞、收藏，并关注我的更新，期待与你共同分享更多技术与思考。

在这里插入图片描述

一只牛博
关注
专栏目录
Swift枚举探秘：解锁枚举的高级特性
07-02
Swift是由苹果公司（Apple Inc.）开发的一种强大且直观的编程语言，专门用于iOS、iPadOS、macOS、watchOS和tvOS等苹果操作系统的应用开发。Swift语言的设计目标是提供安全、快速的性能，并且对开发者友好。 ### ...
JAVA高并发——CompletableFuture
码说芯语的博客
02-27 1000
增强的Future：CompletableFuture
Java并发编程深度解析：掌握CompletableFuture的高效异步模式
weixin_38522648的博客
12-25 1086
CompletableFuture是Java 8中引入的一个类，实现了Future接口并提供了更多的灵活性和控制能力。与传统的Future相比，支持更复杂的操作组合，异常处理，以及函数式编程风格的方法链在Java中提供了一种强大的机制来处理异步编程。它不仅使代码更加简洁，还提高了程序的可读性和可维护性。以下是的一些高级功能和使用方法，涵盖了创建、操作、组合异步任务，以及异常处理等方面在Java中提供了一种强大的异步编程机制。
CompletableFuture与多线程结合使用
果酱 の 博客
05-29 6500
在Java 8中，引入了CompletableFuture类，它是Future的增强版，提供了更加灵活的异步编程方式，能够更好地利用多线程的优势。本文将详细讲解CompletableFuture的使用方法，并结合多线程实现异步编程。CompletableFuture是Java 8中新增的一个类，它实现了Future和CompletionStage接口，提供了一种更加灵活的异步编程方式。
Java并发包之CompletableFuture使用场景以及简单使用(一)
MieMieFly的专栏
09-21 1831
CompletableFuture是Java8提供的一个并发类，方法很多，使用相对复杂。 使用场景：多个线程需要并行或者串行等发杂场景。 先示例一下CompletableFuture的简单场景，上一篇中讲到一个场景是，A和B并行执行，其中结果给C再去执行。 使用CompletableFuture会更简便易于理解。 CompletableFutureDemo.java package com.example.demo.concurrent.completablefuture; import l
java并发之CompletableFuture分析
helloethen的博客
02-26 292
常用方法 thenRun: 任务A执行完，执行任务B，且任务B无返回值。 thenAccept: 任务A执行完以后,执行任务B,且任务B需要A的结果,但任务B无返回值. thenApply: 任务A执行完以后,执行任务B,且任务B需要A的结果,有返回值. ...
地理空间数据探秘：解锁空间分析的代码之门
07-27
### 地理空间数据探秘：解锁空间分析的代码之门 #### 一、地理空间数据分析概述 地理空间数据分析作为一种跨领域的技术手段，融合了地理信息系统（GIS）、数据科学及可视化等多个学科的知识与方法，旨在理解和解读...
Golang反射探秘：编程的瑞士军刀
08-06
3. **并发支持**：Go语言内置了并发编程的支持，通过Goroutines和Channels，可以轻松地实现并发。 4. **内存管理**：Go语言拥有自动垃圾回收机制，简化了内存管理。 5. **静态类型**：Go是一种静态类型语言，这有助...
Ruby语言探秘：从入门到实践，解锁高效编程之旅-markdown案例教程.zip
05-17
Ruby语言探秘：解锁高效编程新境界 你是否对Ruby语言的优雅与强大充满好奇？是否渴望掌握一门能够助你驰骋编程世界的语言？《Ruby语言探秘：从入门到实践》正是你开启高效编程之旅的钥匙。 这不仅仅是一本教程，更...
堆栈探秘：汇编语言中的后进先出世界
最新发布
08-23
汇编语言（Assembly Language）是一种低级编程语言，它用于控制计算机的中央处理器（CPU）。汇编语言与机器码非常接近，几乎是一一对应的关系，但它使用助记符（mnemonics）来代表特定的机器指令，使得程序员更容易...
java并发编程之CompletableFuture
qq_40837310的博客
09-27 608
背景 在一些业务场景下，可能需要对一些任务进行异步化，以提高系统的吞吐量，在微服务的服务调用场景下显得尤为突出。 比如某个接口有五个任务： 任务A：执行时间2秒。 任务B：执行时间2秒。 任务C：执行时间1秒。 任务D：执行时间1秒。 任务E：执行时间1秒。 如果不使用异步任务，使用的是同步任务，那么这个接口的执行总时间至少要7秒中，这在很多场景下是不能接受的。 如果使用异步化，前提是这些任务互不相干，也就是各个任务都不依赖于其他任务的执行结果，那就可以使用任务异步来提高吞吐量，接口执行任务A、B、C、
Java CompletableFuture 并发编程
生而为人我很抱歉
08-11 1170
CompletableFuture 在 Java 里面被用于异步编程，异步通常意味着非阻塞，可以使得我们的任务单独运行在与主线程分离的其他线程中，并且通过回调可以在主线程中得到异步任务的执行状态，是否完成，和是否异常等信息。CompletableFuture 实现了 Future, CompletionStage 接口，实现了 Future接口就可以兼容现在有线程池框架，而 CompletionStage 接口才是异步编程。...
Java并发 - CompletableFuture
DJun的博客
08-25 279
CompletableFuture 可实现并发，主业务线程可以及时释放；异步线程完成工作，执行回调函数，完成善后工作；提高了执行效率。 例如，此时一个线程执行5个步骤的任务，此时第2步操作与后续的3步无关，此时第2步可以异步执行，让后面操作无需等待继续执行。 任务无返回值 public void testFutureVoid() throws ExecutionException, InterruptedException { CompletableFuture<Void> future
Java里面CompletableFuture详解
自我更新
07-31 2万+
Future是Java5添加的类，用来描述一个异步计算的结果。可以用isDone方法来检查计算是否完成，或者使用get阻塞住调用线程，直至计算完成返回结果，也可以用cancel方法来停止任务的执行。 public class BasicFuture { public static void main(String[] args) throws ExecutionException, In
java8新特性（九）：CompletableFuture多线程并发异步编程
热门推荐
不积跬步，无以至千里；不积小流，无以成江海。
11-24 4万+
首先因为现在的应用越来越复杂，越来越多模块多系统之间相互依赖，一个操作可能需要使用多个模块或者多个系统提供的多个服务来完成一个功能，如果每个服务顺序的执行，可能需要消耗很多时间，或者前端用户需要得到及时响应，不需要等待所有服务完成便可以返回部分结果，而且现在的计算机处理器性能越来越强大，多核处理器越来越普遍，核心数也越来越多，使用多线程可以更加充分利用硬件的资源，不论是什么原因异步编程应运而生。
使用CompletableFuture提高并发处理能力
全场梦游c的博客
02-16 1012
背景： 在拼接参数对象时，需要从多个系统里获取参数，比如商品参数要从商品系统获取，价格参数要从价格系统获取，库存参数要从库存系统获取，大部分都是一个rpc调用。 方案： 为了提高接口性能，采用多线程，使用CompletableFuture来完成。 使用到CompletableFuture中的api： 1.异步获取方法的返回值 public static <U> CompletableFuture<U> supplyAsync(Supplier<U> suppl
CompletableFuture多线程并发异步编程
qq_38363255的博客
11-27 2194
  https://blog.csdn.net/sunjin9418/article/details/53321818/     https://blog.csdn.net/itguangit/article/details/78624404    
CompletableFuture实操，提升并发处理能力
qq_28406419的博客
06-18 3465
在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。 它可能代表一个明确完成的Future，也有可能代表一个完成阶段（ CompletionStage ），它支持在计算完成以后触发一些函数或执行某些动作...
CompletableFuture 的并发性能研究
weixin_34162629的博客
01-06 290
为什么80%的码农都做不了架构师？>>> ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一只牛博

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

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

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

打赏作者

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

抵扣说明：

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

余额充值