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(() -> {
// 异步任务 A
return 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());
}