Java 中 Future 接口的使用示例
2021-09-111.2k 阅读
Java 中 Future 接口的使用示例
Future 接口简介
在 Java 编程中，Future 接口是 java.util.concurrent 包的一部分，它为异步计算提供了一种机制。当我们启动一个异步任务时，不能立即获取其结果。Future 接口允许我们检查异步任务是否完成，等待任务完成并获取结果，或者在任务完成之前取消任务。
Future 接口定义了以下几个主要方法：
boolean cancel(boolean mayInterruptIfRunning)：尝试取消执行此任务。如果任务已经完成、已经取消，或者由于某些其他原因无法取消，则此尝试将失败。如果成功取消任务，并且任务尚未启动，则任务将永远不会运行。如果任务已经在运行，并且mayInterruptIfRunning为true，那么正在运行此任务的线程将被中断。boolean isCancelled()：如果在任务正常完成之前将其取消，则返回true。boolean isDone()：如果任务已完成，则返回true。 任务可能由于正常终止、异常或取消而完成，在所有这些情况下，此方法都将返回true。V get()throws InterruptedException, ExecutionException：等待任务完成，然后返回其结果。如果任务在等待时被中断，将抛出InterruptedException。如果任务执行过程中抛出异常，将包装在ExecutionException中抛出。V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException：在指定的时间内等待任务完成，然后返回其结果。如果在规定时间内任务未完成，将抛出TimeoutException。
简单的 Future 使用示例
假设我们有一个简单的任务，它计算两个数的和，并且我们希望以异步方式执行这个任务。
import java.util.concurrent.*;
public class FutureExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> {
// 模拟一些耗时操作
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 3 + 5;
});
try {
System.out.println("等待任务完成...");
Integer result = future.get();
System.out.println("任务结果: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} finally {
executor.shutdown();
}
}
}
在这个示例中：
- 我们首先创建了一个
ExecutorService，这里使用Executors.newSingleThreadExecutor()创建了一个单线程的线程池。 - 然后通过
executor.submit(Callable<T> task)方法提交一个Callable任务。Callable是一个泛型接口，它的call()方法可以返回一个结果并且可以抛出异常。在我们的例子中，call()方法模拟了一个耗时 2 秒的操作，并返回两个数的和。 - 调用
future.get()方法等待任务完成并获取结果。如果任务在执行过程中抛出异常，get()方法会将异常包装在ExecutionException中抛出。如果当前线程在等待过程中被中断，get()方法会抛出InterruptedException。 - 最后，在
finally块中关闭ExecutorService，以确保线程池资源被正确释放。
Future 的取消操作
Future 接口的 cancel() 方法提供了取消异步任务的能力。下面是一个示例，展示如何取消一个正在运行的任务。
import java.util.concurrent.*;
public class FutureCancelExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("任务正在执行: " + i);
if (Thread.currentThread().isInterrupted()) {
System.out.println("任务被中断");
return -1;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.out.println("任务在睡眠中被中断");
return -1;
}
}
return 42;
});
try {
Thread.sleep(3500);
boolean cancelled = future.cancel(true);
System.out.println("任务是否取消: " + cancelled);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
executor.shutdown();
}
}
}
在这个示例中：
- 我们创建了一个
ExecutorService和一个Future，任务在Callable的call()方法中模拟一个循环操作，每次循环暂停 1 秒。 - 在主线程中，我们暂停 3.5 秒，然后调用
future.cancel(true)尝试取消任务。true参数表示如果任务正在运行，将中断执行任务的线程。 - 在任务执行过程中，每次循环都会检查当前线程是否被中断，如果被中断则返回 -1 并打印相应信息。如果在睡眠过程中被中断，会重新设置中断状态并返回 -1。
- 最后，我们打印任务是否成功取消的结果，并关闭
ExecutorService。
Future 的超时获取结果
有时候我们不希望无限期地等待一个异步任务的结果，Future 接口的 get(long timeout, TimeUnit unit) 方法可以帮助我们设置等待的超时时间。
import java.util.concurrent.*;
public class FutureTimeoutExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 10 + 20;
});
try {
System.out.println("等待任务结果，设置超时时间为 3 秒...");
Integer result = future.get(3, TimeUnit.SECONDS);
System.out.println("任务结果: " + result);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
if (e instanceof TimeoutException) {
System.out.println("任务执行超时");
} else {
e.printStackTrace();
}
} finally {
executor.shutdown();
}
}
}
在这个示例中：
- 我们创建了一个需要 5 秒才能完成的异步任务。
- 使用
future.get(3, TimeUnit.SECONDS)方法设置等待任务结果的超时时间为 3 秒。 - 如果任务在 3 秒内没有完成，
get()方法将抛出TimeoutException，我们在catch块中捕获并处理这个异常，打印“任务执行超时”。如果任务在 3 秒内完成，则正常获取并打印任务结果。 - 最后，关闭
ExecutorService。
FutureTask 类
FutureTask 类是 Future 接口的一个实现，它同时实现了 Runnable 接口，这意味着它既可以作为 Runnable 被执行，也可以作为 Future 来获取异步任务的结果。
import java.util.concurrent.*;
public class FutureTaskExample {
public static void main(String[] args) {
FutureTask<Integer> futureTask = new FutureTask<>(() -> {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 7 + 8;
});
Thread thread = new Thread(futureTask);
thread.start();
try {
System.out.println("等待任务完成...");
Integer result = futureTask.get();
System.out.println("任务结果: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
在这个示例中：
- 我们创建了一个
FutureTask，它的构造函数接受一个Callable。在Callable的call()方法中模拟了一个 3 秒的耗时操作，并返回两个数的和。 - 创建一个新线程并将
FutureTask作为Runnable传递给线程，然后启动线程。 - 在主线程中，通过
futureTask.get()等待任务完成并获取结果，处理可能抛出的InterruptedException和ExecutionException。
结合 CompletionService 使用 Future
CompletionService 结合了 Executor 和 BlockingQueue 的功能。它允许我们提交一组异步任务，并按照任务完成的顺序获取结果，而不是按照提交的顺序。
import java.util.concurrent.*;
public class CompletionServiceExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(3);
CompletionService<Integer> completionService = new ExecutorCompletionService<>(executor);
for (int i = 0; i < 5; i++) {
final int taskNumber = i;
completionService.submit(() -> {
int sleepTime = (int) (Math.random() * 5000);
System.out.println("任务 " + taskNumber + " 开始，睡眠 " + sleepTime + " 毫秒");
Thread.sleep(sleepTime);
return taskNumber * 10;
});
}
for (int i = 0; i < 5; i++) {
try {
Future<Integer> future = completionService.take();
System.out.println("获取到任务结果: " + future.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
executor.shutdown();
}
}
在这个示例中：
- 我们创建了一个固定大小为 3 的线程池
ExecutorService和一个ExecutorCompletionService，它使用这个线程池来执行任务。 - 通过循环提交 5 个异步任务，每个任务随机睡眠一段时间（0 到 5 秒之间），然后返回任务编号乘以 10 的结果。
- 另一个循环通过
completionService.take()方法获取已完成的任务的Future，take()方法会阻塞直到有任务完成。然后通过future.get()获取任务结果并打印。 - 最后关闭
ExecutorService。
实际应用场景
- Web 应用中的异步数据加载：在 Web 应用开发中，当需要从多个数据源获取数据并组合显示时，可以使用
Future以异步方式从不同数据源获取数据，提高响应速度。例如，一个页面需要同时展示用户信息、用户的订单列表和用户的积分信息，这三个数据可以通过三个异步任务分别从用户数据库、订单数据库和积分系统获取，然后在所有任务完成后组合数据并返回给客户端。 - 大数据处理：在大数据处理场景中，可能需要对大规模数据进行多个不同的分析任务，这些任务可以异步执行。例如，一个数据分析系统需要同时计算数据的平均值、中位数和标准差，每个计算任务可以作为一个异步任务提交，使用
Future来管理这些任务的执行和获取结果。 - 分布式系统中的远程调用优化：在分布式系统中，当调用远程服务时，可能会有一定的延迟。通过使用
Future进行异步调用，可以在等待远程服务响应的同时执行其他本地任务，提高系统的整体效率。例如，一个微服务架构的应用中，某个服务需要调用另一个远程微服务获取数据，同时可以利用等待时间对本地缓存的数据进行预处理。
Future 接口的局限性
- 缺乏回调机制：
Future接口没有提供直接的回调机制。如果我们需要在任务完成后执行一些操作，只能通过轮询isDone()方法或者在get()方法阻塞等待结果后执行。这在某些场景下不够灵活，尤其是当有大量异步任务需要处理时，轮询会消耗大量资源，而阻塞等待会影响程序的并发性能。 - 异常处理不够优雅：
Future的get()方法会将任务执行过程中的异常包装在ExecutionException中抛出，需要在调用处显式捕获并处理。这使得代码中充斥着异常处理逻辑，不够简洁。并且如果有多个异步任务同时执行，处理每个任务的异常会变得更加复杂。 - 难以组合多个 Future：当需要组合多个
Future的结果时，例如先执行一个任务获取结果，然后根据这个结果执行另一个任务，使用Future接口实现起来比较繁琐。需要手动管理每个任务的依赖关系和执行顺序，缺乏简洁的方式来表达这种复杂的异步任务组合。
总结 Future 接口的使用要点
- 任务提交与执行：通过
ExecutorService的submit()方法提交Callable任务来获取Future，或者直接创建FutureTask并通过线程执行。确保合理选择线程池的类型和大小，以优化资源利用和性能。 - 结果获取与异常处理：使用
get()方法获取任务结果时，要注意处理InterruptedException和ExecutionException。如果设置了超时时间，还需要处理TimeoutException。合理的异常处理可以增强程序的健壮性。 - 任务取消：了解
cancel()方法的使用，以及如何在任务内部正确响应中断，以确保任务能够在需要时被顺利取消。 - 结合其他工具：如
CompletionService等，来优化异步任务的管理和结果获取，尤其是在处理多个异步任务的场景下。
虽然 Future 接口存在一些局限性，但在许多异步编程场景中，它仍然是一个非常有用的工具。随着 Java 并发编程框架的发展，如 CompletableFuture 的出现，在一定程度上弥补了 Future 接口的不足，为开发者提供了更强大、更灵活的异步编程能力。但理解 Future 接口的基本原理和使用方法，对于深入掌握 Java 并发编程仍然是至关重要的。
在实际应用中，根据具体的业务需求和场景，合理选择和使用 Future 接口及其相关工具，可以显著提升程序的性能和响应能力，充分发挥多核处理器的优势，实现高效的异步编程。通过不断实践和优化，开发者能够更好地利用 Future 接口来构建健壮、高性能的 Java 应用程序。无论是小型的桌面应用还是大型的分布式系统，Future 接口都在异步处理领域发挥着重要的作用。同时，随着技术的不断进步，我们也应关注新的异步编程模型和工具，以便在不同的场景下选择最合适的解决方案。例如，在响应式编程流行的今天，结合响应式框架和 Future 相关知识，可以创造出更具表现力和高效的异步应用。
在并发编程的道路上，对 Future 接口的深入理解只是一个起点。它与线程池、并发集合等其他并发工具相互配合，共同构成了 Java 强大的并发编程体系。通过不断探索和实践这些工具的组合使用，开发者可以解决各种复杂的并发问题，开发出性能卓越、可扩展性强的应用程序。无论是在后端服务开发、大数据处理，还是在移动应用的异步任务管理中，Future 接口及其相关技术都有着广泛的应用前景。我们应该不断学习和研究，将这些技术运用到实际项目中，提升软件的质量和用户体验。同时，关注行业动态和技术发展趋势，以便及时引入新的技术和理念，优化我们的编程方法和架构设计。总之，Future 接口作为 Java 并发编程的重要组成部分，值得我们深入研究和熟练掌握。