future和CompletableFuture

future

什么是future

Future 类是并发编程中一个非常重要的工具。它主要用于表示一个异步计算的结果，允许你在计算完成后获取结果或处理异常。Java 的 Future 也常常与线程池（如 ExecutorService）结合使用，用来执行并行任务，并返回任务的执行结果。

Java 中的 Future 主要用于以下几个场景：

异步计算：当我们希望在不阻塞主线程的情况下执行任务，并能在稍后获取任务的结果时，可以使用 Future。
任务控制：通过 Future，我们可以检查任务是否完成，获取任务的执行结果，或者取消正在执行的任务。
避免阻塞：Future 允许我们在等待计算结果时，不会阻塞主线程。

future常见方法

在 Java 中，Future 类提供了几种常见的方法来管理异步任务的执行：

get()：等待异步任务完成并获取结果，如果任务抛出异常，会重新抛出该异常。
get(long timeout, TimeUnit unit)：带有超时限制的 get 方法，等待任务完成的最长时间，超时后抛出 TimeoutException。
cancel(boolean mayInterruptIfRunning)：取消任务。如果任务已经开始执行，且 mayInterruptIfRunning 为 true，会中断任务。
isDone()：检查任务是否已经完成。
isCancelled()：检查任务是否已经被取消。

使用示例

get()简单的异步任务

使用 ExecutorService 提交任务，并通过 Future 获取任务的结果

import java.util.concurrent.*;public class FutureExample {public static void main(String[] args) throws InterruptedException, ExecutionException {ExecutorService executorService = Executors.newFixedThreadPool(1);// 提交一个异步任务Future<Integer> future = executorService.submit(() -> {// 模拟一些计算Thread.sleep(2000);return 42;  // 返回结果});// 在任务完成之前执行其他操作System.out.println("Main thread is doing other work...");// 获取任务的结果，若任务未完成，则会阻塞直到任务完成Integer result = future.get();  // 阻塞直到任务完成System.out.println("Task result: " + result);executorService.shutdown();}
}

带超时的 get() 方法

Future 的 get(long timeout, TimeUnit unit) 方法允许我们为任务设置一个超时。如果在指定的时间内任务没有完成，会抛出 TimeoutException。

import java.util.concurrent.*;public class FutureTimeoutExample {public static void main(String[] args) {ExecutorService executorService = Executors.newFixedThreadPool(1);// 提交一个任务Future<Integer> future = executorService.submit(() -> {Thread.sleep(5000);  // 模拟长时间任务return 100;});try {// 设置超时，等待最多 3 秒Integer result = future.get(3, TimeUnit.SECONDS);System.out.println("Task result: " + result);} catch (TimeoutException e) {System.out.println("Task timed out!");future.cancel(true);  // 取消任务} catch (InterruptedException | ExecutionException e) {System.out.println("An error occurred: " + e.getMessage());}executorService.shutdown();}
}

取消任务cancel(boolean mayInterruptIfRunning)

通过 future.cancel(true) 来取消任务。true 表示如果任务已经开始执行，允许中断任务。

import java.util.concurrent.*;public class FutureCancelExample {public static void main(String[] args) throws InterruptedException {ExecutorService executorService = Executors.newFixedThreadPool(1);// 提交一个长时间运行的任务Future<Integer> future = executorService.submit(() -> {Thread.sleep(5000);return 100;});// 让主线程等待 2 秒钟Thread.sleep(2000);// 取消任务boolean isCancelled = future.cancel(true);if (isCancelled) {System.out.println("Task was successfully cancelled.");} else {System.out.println("Task could not be cancelled.");}executorService.shutdown();}
}

批量任务处理与 isDone() 方法

在实际开发中，有时我们需要提交多个任务，并等待它们完成。可以使用 isDone() 来检查每个任务是否已完成。

import java.util.concurrent.*;public class FutureBatchExample {public static void main(String[] args) throws InterruptedException {ExecutorService executorService = Executors.newFixedThreadPool(3);// 提交多个任务Future<Integer> future1 = executorService.submit(() -> {Thread.sleep(1000);return 10;});Future<Integer> future2 = executorService.submit(() -> {Thread.sleep(2000);return 20;});Future<Integer> future3 = executorService.submit(() -> {Thread.sleep(3000);return 30;});// 检查任务是否完成while (!future1.isDone() || !future2.isDone() || !future3.isDone()) {System.out.println("Waiting for tasks to complete...");Thread.sleep(500);}System.out.println("Task 1 result: " + future1.get());System.out.println("Task 2 result: " + future2.get());System.out.println("Task 3 result: " + future3.get());executorService.shutdown();}
}

CompletableFuture

什么是CompletableFuture

CompletableFuture 是 Java 8 引入的一个类，位于 java.util.concurrent 包中。它是 Future 类的一个增强版本，用于处理异步编程。与 Future 类不同，CompletableFuture 不仅支持基本的异步任务执行和结果获取，还提供了更多的功能，允许任务的组合、回调的注册、异常处理以及支持非阻塞地执行多个任务。

CompletableFuture和future的区别

特性	Future	CompletableFuture
异步计算结果的获取	通过 get() 方法，获取结果时会阻塞当前线程。	支持非阻塞的异步计算，使用 thenApply() 等方法继续处理结果。
任务组合	不支持任务的组合，无法在多个任务完成后做进一步操作。	支持任务的组合，提供 thenApply(), thenCombine(), allOf() 等方法来组合多个异步任务。
异常处理	如果任务执行出现异常，可以通过 get() 抛出异常，但没有方便的回调处理机制。	支持更丰富的异常处理，通过 handle(), exceptionally() 等方法处理异常。
任务手动完成	不支持手动完成任务。	可以手动完成任务，使用 complete() 或 completeExceptionally() 来控制任务的完成。
响应式编程	仅支持简单的异步结果获取。	支持响应式编程，能够注册多个回调处理器来响应任务的状态变化

CompletableFuture的常用方法

supplyAsync()：异步执行一个返回结果的任务。
runAsync()：异步执行一个没有返回结果的任务。
thenApply()：任务完成后，基于结果执行一个转换操作。
thenAccept()：任务完成后，基于结果执行一个操作，但不返回结果。
thenCombine()：当两个任务都完成时，结合两个任务的结果。
exceptionally()：处理异步任务的异常。
allOf()：等待多个任务同时完成。
anyOf()：等待多个任务中任意一个完成。

CompletableFuture使用案例

基本的异步计算

使用 supplyAsync() 提交了一个异步任务，主线程通过 get() 等待异步任务的完成并获取结果。

import java.util.concurrent.*;public class CompletableFutureExample {public static void main(String[] args) throws InterruptedException, ExecutionException {// 使用 supplyAsync 异步执行任务CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {// 模拟一个长时间的计算try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }return 42;  // 返回结果});// 获取计算结果（会阻塞直到结果完成）Integer result = future.get();System.out.println("Task result: " + result);}
}

任务的组合

通过 thenApply() 和 thenCombine() 等方法，我们可以将多个异步任务组合在一起，完成更复杂的计算。

import java.util.concurrent.*;public class CompletableFutureCombinationExample {public static void main(String[] args) throws InterruptedException, ExecutionException {CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);// thenCombine() 用于将两个异步任务的结果合并CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (x, y) -> x + y);// 获取合并结果Integer result = combinedFuture.get();System.out.println("Combined result: " + result);  // 输出 30}
}

异常处理

CompletableFuture 提供了更好的异常处理机制，可以通过 exceptionally() 来处理任务中的异常。

import java.util.concurrent.*;public class CompletableFutureExceptionExample {public static void main(String[] args) throws InterruptedException, ExecutionException {CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {if (true) {throw new RuntimeException("Something went wrong!");}return 42;});// 使用 exceptionally() 处理异常CompletableFuture<Integer> handledFuture = future.exceptionally(ex -> {System.out.println("Handling exception: " + ex.getMessage());return 0;  // 异常处理后返回默认值});Integer result = handledFuture.get();System.out.println("Task result: " + result);  // 输出 "Task result: 0"}
}

等待多个任务

通过 allOf() 方法，我们可以等待多个异步任务全部完成，然后处理它们的结果。

import java.util.concurrent.*;public class CompletableFutureAllOfExample {public static void main(String[] args) throws InterruptedException, ExecutionException {CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> 30);// 等待所有任务完成CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2, future3);// 等待所有任务完成后获取结果allOf.get();  // 阻塞，直到所有任务完成// 获取每个任务的结果System.out.println("Result of future1: " + future1.get());System.out.println("Result of future2: " + future2.get());System.out.println("Result of future3: " + future3.get());}
}

响应式编程

CompletableFuture 支持更为灵活的异步执行流，可以在任务完成后注册回调处理。

import java.util.concurrent.*;public class CompletableFutureCallbackExample {public static void main(String[] args) {CompletableFuture.supplyAsync(() -> {return 42;}).thenApply(result -> {System.out.println("Task result: " + result);return result * 2;  // 处理任务结果}).thenAccept(finalResult -> {System.out.println("Final result: " + finalResult);  // 输出最终结果});}
}

那么是否是CompletableFuture能完全替代Future

可以的，可以理解为CompletableFuture是Future的增强版本，就像Springboot能完全替代SpringMVC一样

CompletableFuture 完全可以替代 Future，因为它提供了 Future 的所有功能，并增加了更多强大的特性，如任务组合、异常处理、回调等。

对于复杂的异步操作和任务链式调用，CompletableFuture 是更好的选择，它使得异步编程更加灵活和简洁。

对于简单的任务执行和结果获取，如果没有任务组合、回调和异常处理的需求，Future 仍然是一个简单有效的选择。

总结来说，CompletableFuture 是更现代和强大的异步工具，Future 仍然可以在某些简单场景下使用，但大多数情况可以考虑使用 CompletableFuture 来简化代码并提高效率。

Future用来接收excutorservice执行的线程池，而Completable底层也是执行的线程池，使用默认线程池 ForkJoinPool.commonPool()，且可以更改为自定义的线程池，所以和Futre并没什么实质上的区别，只是一个增强版