在多线程编程中，Callable 和 Future 提供了一种强大的方式来处理异步任务，它们解决了 Runnable 无法返回结果以及无法处理异常的问题。通过 Callable 和 Future，你可以实现更加高效和灵活的线程管理。本篇博客将详细探讨 Callable 与 Runnable 的区别，Future 的作用以及如何利用这些工具提高程序的性能。
1. Callable 和 Runnable 的不同
首先，让我们了解 Runnable 和 Callable 两者的区别：
Runnable 的定义：
public interface Runnable {
public abstract void run();
}
Callable 的定义：
public interface Callable<V> {
V call() throws Exception;
}
主要区别：
-
返回值：
Runnable的run()方法没有返回值，适用于不需要返回结果的任务。Callable的call()方法有返回值，适用于需要返回结果的任务。
-
异常处理：
Runnable的run()方法不能抛出受检查异常（checked exceptions）。Callable的call()方法可以抛出受检查异常（checked exceptions），这使得它更适合复杂的任务。
-
应用场景：
- 如果你的任务不需要返回值或抛出异常，
Runnable是足够的。 - 如果你需要任务的结果或任务执行过程中可能会抛出异常，
Callable是必选的。
- 如果你的任务不需要返回值或抛出异常，
2. 为什么需要 Callable？
Runnable 在设计时并没有考虑到需要返回结果或处理异常的情况。我们可以使用一些其他的间接方法（如写入共享资源或日志文件）来获取 Runnable 执行的结果，但这种方式非常笨拙且低效。
Callable 设计的目标是解决以下问题：
- 任务返回值：
Callable能直接返回任务执行的结果，不需要额外的步骤。 - 异常处理：
Callable能够抛出异常，使得异常管理更加方便和规范。
3. Callable 与 Future 的关系
Future 是一个接口，它表示异步计算的结果。通过 Future，你可以获取 Callable 任务的执行结果，判断任务是否完成，甚至取消任务。Callable 任务的结果就是通过 Future 获取的。
Future 的作用：
Future 主要用于处理长时间运行的任务。我们可以将任务交给后台线程执行，而主线程继续处理其他任务，待后台任务完成后通过 Future 获取结果。
Callable 和 Future 的关系：
Callable的任务通过Future进行管理。Future提供了方法来获取任务结果（get()）、判断任务是否完成（isDone()）、取消任务（cancel()）等功能。
4. Future 的方法和用法
Future 接口定义了五个方法，帮助管理异步任务的执行：
1. get() 获取结果
get() 方法用于获取任务的执行结果。它会阻塞当前线程，直到任务完成并返回结果。若任务执行过程中抛出异常，get() 会抛出 ExecutionException。
V get() throws InterruptedException, ExecutionException;
- 阻塞：如果任务尚未完成，
get()会阻塞当前线程，直到任务完成。 - 异常处理：任务执行过程中抛出的异常，会被包装成
ExecutionException抛出。
2. isDone() 判断任务是否执行完毕
该方法用于判断任务是否已完成，不会阻塞线程。
boolean isDone();
- 如果任务已完成（无论成功、失败还是取消），返回
true，否则返回false。
3. cancel() 取消任务
cancel() 方法用于取消任务的执行。
boolean cancel(boolean mayInterruptIfRunning);
- 如果任务尚未开始执行，则取消任务并返回
true。 - 如果任务正在执行，可以选择是否中断执行，
mayInterruptIfRunning参数决定是否中断正在执行的任务。
4. isCancelled() 判断任务是否被取消
该方法用于判断任务是否被取消。
boolean isCancelled();
- 如果任务已被取消，返回
true，否则返回false。
5. 使用 FutureTask 来创建 Future
FutureTask 是 RunnableFuture 接口的实现，它既实现了 Runnable 接口（可以交给线程池执行），也实现了 Future 接口（可以获取任务的执行结果）。FutureTask 既能作为任务执行，也能作为 Future 获取任务结果。
FutureTask 示例：
public class FutureTaskDemo {
public static void main(String[] args) {
Task task = new Task();
FutureTask<Integer> integerFutureTask = new FutureTask<>(task);
new Thread(integerFutureTask).start();
try {
System.out.println("Task result: " + integerFutureTask.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
class Task implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
sum += i;
}
return sum;
}
}
在上面的示例中，FutureTask 将 Callable 任务包装为一个 Runnable 对象，可以通过 FutureTask 获取任务的结果。
6. Future 使用注意事项
- 批量获取结果时容易阻塞：当使用
Future批量获取任务的结果时，可能会造成线程阻塞。建议为get()方法设置timeout限制。 - 生命周期不能后退：一旦任务完成，
Future的状态无法重置。任务完成后，Future不能重新启动。 - 并不会自动创建线程：
Callable和Future本身并不创建线程，它们依赖于Thread或线程池来执行任务。
7. 实际应用：旅游平台的异步处理
假设你在开发一个旅游平台，需要从多个供应商那里获取不同的价格数据。使用 Future 结合 Callable 可以帮助你异步执行多个任务，并在所有任务完成后统一获取结果。
CountDownLatch 示例：
public class CountDownLatchDemo {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
public static void main(String[] args) throws InterruptedException {
CountDownLatchDemo countDownLatchDemo = new CountDownLatchDemo();
System.out.println(countDownLatchDemo.getPrices());
}
private Set<Integer> getPrices() throws InterruptedException {
Set<Integer> prices = Collections.synchronizedSet(new HashSet<Integer>());
CountDownLatch countDownLatch = new CountDownLatch(3);
threadPool.submit(new Task(123, prices, countDownLatch));
threadPool.submit(new Task(456, prices, countDownLatch));
threadPool.submit(new Task(789, prices, countDownLatch));
countDownLatch.await(3, TimeUnit.SECONDS);
return prices;
}
private class Task implements Runnable {
Integer productId;
Set<Integer> prices;
CountDownLatch countDownLatch;
public Task(Integer productId, Set<Integer> prices, CountDownLatch countDownLatch) {
this.productId = productId;
this.prices = prices;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
int price = 0;
try {
Thread.sleep((long) (Math.random() * 4000));
price = (int) (Math.random() * 4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
prices.add(price);
countDownLatch.countDown();
}
}
}
在这个例子中，CountDownLatch 被用来等待所有的任务完成后再返回结果。
总结
Callable 和 Future 提供了强大的功能来执行异步任务和管理任务的执行结果。相比于 Runnable，Callable 允许任务有返回值，并且可以处理异常。而 Future 则为任务提供了取消、查询执行状态等管理功能。通过合理使用 Callable 和 Future，你可以更高效地处理并发任务，提高程序的运行效率和稳定性。
希望本篇文章能帮助你深入理解 Callable 和 Future，并在项目中灵活运用！