CompletableFuture
是 Java 8 引入的一个强大的异步编程工具类,它实现了 Future
和 CompletionStage
接口,提供了丰富的方法来处理异步任务的创建、组合、结果获取等操作。以下是对 CompletableFuture
基本异步方法的详细介绍:
runAsync(Runnable runnable)
Runnable
任务,不返回结果。默认使用 ForkJoinPool.commonPool()
线程池。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future = CompletableFuture.runAsync(() -> {
System.out.println("Running task asynchronously...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task completed.");
});
// 等待任务完成
future.join();
}
}
runAsync(Runnable runnable, Executor executor)
Runnable
任务,不返回结果,使用指定的线程池 executor
。java
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CompletableFutureExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture future = CompletableFuture.runAsync(() -> {
System.out.println("Running task asynchronously with custom executor...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task completed.");
}, executor);
// 等待任务完成
future.join();
executor.shutdown();
}
}
supplyAsync(Supplier supplier)
Supplier
任务,返回一个 CompletableFuture
对象,该对象最终会包含 Supplier
的返回值。默认使用 ForkJoinPool.commonPool()
线程池。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
System.out.println("Running task asynchronously...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task result";
});
// 获取任务结果
String result = future.join();
System.out.println("Result: " + result);
}
}
supplyAsync(Supplier supplier, Executor executor)
Supplier
任务,返回一个 CompletableFuture
对象,该对象最终会包含 Supplier
的返回值,使用指定的线程池 executor
。java
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CompletableFutureExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor();
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
System.out.println("Running task asynchronously with custom executor...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task result";
}, executor);
// 获取任务结果
String result = future.join();
System.out.println("Result: " + result);
executor.shutdown();
}
}
thenApply(Function super T,? extends U> fn)
CompletableFuture
完成时,对其结果应用一个函数,并返回一个新的 CompletableFuture
,该新 CompletableFuture
的结果是函数的返回值。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello")
.thenApply(s -> s + " World");
String result = future.join();
System.out.println(result); // 输出: Hello World
}
}
thenAccept(Consumer super T> action)
CompletableFuture
完成时,对其结果执行一个消费操作,不返回结果,返回的 CompletableFuture
类型为 CompletableFuture
。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello")
.thenAccept(s -> System.out.println(s));
future.join(); // 输出: Hello
}
}
thenRun(Runnable action)
CompletableFuture
完成时,执行一个 Runnable
任务,不关心原任务的结果,返回的 CompletableFuture
类型为 CompletableFuture
。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello")
.thenRun(() -> System.out.println("Task completed"));
future.join(); // 输出: Task completed
}
}
CompletableFuture
thenCompose(Function super T, ? extends CompletionStage> fn)
CompletableFuture
完成时,将其结果传递给一个函数,该函数返回另一个 CompletionStage
,最终返回一个新的 CompletableFuture
,该新 CompletableFuture
的结果是嵌套 CompletionStage
的结果。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello")
.thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " World"));
String result = future.join();
System.out.println(result); // 输出: Hello World
}
}
thenCombine(CompletionStage extends U> other, BiFunction super T,? super U,? extends V> fn)
CompletableFuture
和另一个 CompletionStage
都完成时,将它们的结果传递给一个二元函数,并返回一个新的 CompletableFuture
,该新 CompletableFuture
的结果是二元函数的返回值。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture future2 = CompletableFuture.supplyAsync(() -> " World");
CompletableFuture combinedFuture = future1.thenCombine(future2, (s1, s2) -> s1 + s2);
String result = combinedFuture.join();
System.out.println(result); // 输出: Hello World
}
}
allOf(CompletableFuture>... cfs)
CompletableFuture
,当所有给定的 CompletableFuture
都完成时,该新 CompletableFuture
完成。它不返回任何结果,类型为 CompletableFuture
。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future1 = CompletableFuture.supplyAsync(() -> "Result 1");
CompletableFuture future2 = CompletableFuture.supplyAsync(() -> "Result 2");
CompletableFuture allFutures = CompletableFuture.allOf(future1, future2);
allFutures.join();
System.out.println("All tasks completed");
}
}
anyOf(CompletableFuture>... cfs)
CompletableFuture
,当任何一个给定的 CompletableFuture
完成时,该新 CompletableFuture
完成,其结果是第一个完成的 CompletableFuture
的结果。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Result 1";
});
CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Result 2";
});
CompletableFuture
exceptionally(Function fn)
CompletableFuture
出现异常时,将异常传递给一个函数,该函数返回一个默认值,最终返回一个新的 CompletableFuture
,其结果是函数的返回值。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
throw new RuntimeException("Something went wrong");
}).exceptionally(ex -> {
System.out.println("Exception caught: " + ex.getMessage());
return "Default result";
});
String result = future.join();
System.out.println(result); // 输出: Default result
}
}
handle(BiFunction super T, Throwable, ? extends U> fn)
CompletableFuture
是否完成或出现异常,都将结果(或 null
,如果出现异常)和异常(或 null
,如果没有异常)传递给一个二元函数,并返回一个新的 CompletableFuture
,其结果是二元函数的返回值。java
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
throw new RuntimeException("Something went wrong");
}).handle((result, ex) -> {
if (ex != null) {
System.out.println("Exception caught: " + ex.getMessage());
return "Default result";
}
return result;
});
String result = future.join();
System.out.println(result); // 输出: Default result
}
}
以上就是 CompletableFuture
的一些基本异步方法的介绍,通过这些方法可以方便地进行异步编程和任务组合。