Java中常用的异步方法

1、使用线程：你可以创建一个新的线程来执行异步操作。这可以通过直接创建Thread对象并启动它，或者使用线程池来管理线程的生命周期。

new Thread(() -> {// 异步操作代码
}).start();

2、使用线程池Executor框架：Executor框架提供了一种更高级别的异步执行机制，可以管理线程池和任务调度。

ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(() -> {// 异步操作代码
});
executor.shutdown();

3、使用Java 8引入的CompletableFuture类：CompletableFuture类提供了一种更便捷的方式来执行异步操作，并处理操作完成后的结果。

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {// 异步操作代码
});// 可以在异步操作完成后执行回调函数
future.thenRun(() -> {// 操作完成后的处理代码
});

4、使用第三方库：除了Java内置的工具，还有许多第三方库可用于实现异步操作，例如Guava的ListenableFuture等。

CompletableFuture类使用

CompletableFuture 类是 Java 中用于处理异步编程的强大工具。下面是 CompletableFuture 类的一些常用方法的详细解释： 

1.  supplyAsync(Supplier<U> supplier) ：创建一个 CompletableFuture，该 CompletableFuture 会异步执行 Supplier 方法，并返回计算结果。  

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {// 异步操作：计算两个整数的和int a = 5;int b = 10;return a + b;
});
// get() 方法，该方法是阻塞的，直到异步操作完成或超时。
Integer val = future.get();
System.out.println("获取异步加载的值:" + val);

2.  thenApply(Function<? super T,? extends U> fn) ：在 CompletableFuture 完成后应用给定的函数 fn，将 CompletableFuture 的结果转换为另一种类型，并返回一个新的 CompletableFuture。  

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {// 异步操作：获取用户年龄return getUserAge();
}).thenApply(age -> {// 将年龄转换为字符串return "返回用户年龄信息: " + String.valueOf(age);
});

3.  thenAccept(Consumer<? super T> action) ：在 CompletableFuture 完成后执行给定的动作 action，对 CompletableFuture 的结果进行消费，但不返回新的 CompletableFuture。  

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {// 异步操作：获取用户年龄return getUserAge();
}).thenAccept(age -> {// 没有返回值System.out.println("thenAccept没有返回值: " + String.valueOf(age));
});

4.  thenRun(Runnable action) ：在 CompletableFuture 完成后执行给定的动作 action，对 CompletableFuture 的结果不进行消费，也不返回新的 CompletableFuture。  

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {// 返回值return "Result";
});CompletableFuture<Void> thenRunFuture = future.thenRun(() -> {// 使用 thenRun() 执行一个操作，在计算完成后打印一条消息System.out.println("执行完成!");
});// 获取值
thenRunFuture.get();

5.  thenCompose(Function<? super T,? extends CompletionStage<U>> fn) ：在 CompletableFuture 完成后应用给定的函数 fn，将 CompletableFuture 的结果传递给该函数，并返回一个新的 CompletableFuture。简单的说就是用于将两个 CompletableFuture 对象串联起来执行。

// 使用场景：
// 假设有两个异步任务，任务 A 返回一个结果，任务 B 根据任务 A 的结果进行计算并返回最终结果。
CompletableFuture<Integer> futureA = CompletableFuture.supplyAsync(() -> {// 异步任务 Areturn 2;
});CompletableFuture<Integer> futureB = futureA.thenCompose(resultA -> {// 异步任务 B，根据任务 A 的结果进行计算int resultB = resultA * 3;return CompletableFuture.completedFuture(resultB);
});// 最终结果输出6
futureB.thenAccept(finalResult -> System.out.println("最终结果：" + finalResult));

6.  exceptionally(Function<Throwable,? extends T> fn) ：在 CompletableFuture 发生异常时应用给定的函数 fn，返回一个新的 CompletableFuture，该 CompletableFuture 的结果是由异常处理函数提供的，用于处理异步任务中的异常情况.

// 使用场景：
// 假设有一个异步任务，计算两个数的商，出现除零异常。在发生异常时返回一个默认值
CompletableFuture<Double> future = CompletableFuture.supplyAsync(() -> {int dividend = 10;int divisor = 0;return dividend / divisor;
});CompletableFuture<Double> resultFuture = future.exceptionally(ex -> {System.out.println("发生异常：" + ex);return 0.0; // 返回默认值
});// 输出：
// 发生异常：java.lang.ArithmeticException: / by zero
// 计算结果：0.0
resultFuture.thenAccept(result -> System.out.println("计算结果：" + result));

7.  handle(BiFunction<? super T,Throwable,? extends U> fn) ：在 CompletableFuture 完成后应用给定的函数 fn，无论 CompletableFuture 是否发生异常，该函数都会被调用，并返回一个新的 CompletableFuture，用于处理异步任务的结果（包括正常结果和异常情况）。

CompletableFuture<Double> future = CompletableFuture.supplyAsync(() -> {int dividend = 10;int divisor = 2;return dividend / divisor;
});CompletableFuture<String> resultFuture = future.handle((result, ex) -> {if (ex != null) {System.out.println("发生异常：" + ex);return "默认值"; // 返回默认值} else {return "计算结果：" + result;}
});// 输出：
// 计算结果：5.0
resultFuture.thenAccept(result -> System.out.println(result));

8.  allOf(CompletableFuture<?>... cfs) ：等待多个 CompletableFuture 完成，并返回一个新的 CompletableFuture，该新的 CompletableFuture 在所有输入的 CompletableFuture 都完成后才会完成。 

注意：allOf() 方法返回的是 CompletableFuture<Void> ，因为它只关注所有CompletableFuture的完成状态，而不关心具体的结果。如果你需要获取每个CompletableFuture的结果，你可以在 allOf() 之后使用 get() 方法来获取每个CompletableFuture的结果。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;public class CompletableFutureExample {public static void main(String[] args) {CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return "Result from Future 1";});CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return "Result from Future 2";});CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}return "Result from Future 3";});CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);try {allFutures.get();System.out.println("所有任务都完成了，开始获取值：");System.out.println("获取 Future 1 的值: " + future1.get());System.out.println("获取 Future 2 的值: " + future2.get());System.out.println("获取 Future 3 的值: " + future3.get());} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}
}

9.  anyOf(CompletableFuture<?>... cfs) ：等待多个 CompletableFuture 中的任意一个完成，并返回一个新的 CompletableFuture，该新的 CompletableFuture 在其中任意一个 CompletableFuture 完成时就会完成。 

CompletableFuture.anyOf() 方法常用于以下场景：当你想并发执行多个异步任务，并且只需要获取第一个完成的任务的结果时，它非常有用。在有多个独立任务且只关心第一个成功完成的任务结果时，它可以发挥作用。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;public class CompletableFutureExample {public static void main(String[] args) {CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}return "Result from Future 1";});CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}return "Result from Future 2";});CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}return "Result from Future 3";});CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2, future3);try {System.out.println("打印任务的完成状态: " + anyFuture.isDone());Object result = anyFuture.get();System.out.println("有一个任务完成了，就不管别的任务了: " + result);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}}
}

Future 和 AsyncResult的区别和使用场景

1. Future 接口： 
   - Future 接口是 Java 提供的一个异步操作的结果的占位符。它表示一个可能完成或者失败的异步操作。 
   - Future 接口提供了一些方法（如  get() 、 isDone() 、 cancel()  等）来获取异步操作的结果、检查操作是否完成以及取消操作。 
   - Future 接口的一个主要限制是它只能通过轮询来判断异步操作是否完成，这样可能会导致线程阻塞。 

// get()获取值
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello, World!");
String result = future.get();
System.out.println("阻塞直到获取值" + result);// isDone()是否完成
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello, World!");
boolean done = future.isDone();
System.out.println("任务是否完成：" + done);// cancel()取消异步任务的执行
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {// 模拟一个长时间运行的任务try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}return "Hello, World!";
});
boolean canceled = future.cancel(true);
System.out.println("任务是否被取消：" + canceled);

2. AsyncResult 接口： 
   - AsyncResult 接口是 Vert.x 框架中的一个特定实现，用于表示异步操作的结果。 
   - AsyncResult 接口继承自 Future 接口，并提供了更多的方法和功能，使得处理异步操作更加方便。 
   - AsyncResult 接口提供了一种更灵活的方式来处理异步操作的结果，包括处理成功和失败的情况，并可以获取操作的异常信息。 

// 此处使用了异步注解、结合AsyncResult使用的举例
@Async(THREAD_NAME)
public Future<Integer> ruleTotal() {return new AsyncResult<Integer>(testMapper.obtainCount());
}