Java中Callable的应用

在Java中，Callable接口是一种用于并发编程的接口，它与Runnable类似，但有一些重要的区别和优势。Callable接口提供了一种在多线程环境下执行任务并返回结果的方法。以下是一些Callable接口的常见应用场景和使用示例：

Callable vs. Runnable

返回值：Runnable接口的run方法不能返回结果，而Callable接口的call方法可以返回一个结果。
异常处理：Runnable的run方法不能抛出检查型异常，而Callable的call方法可以抛出异常。

应用场景

需要返回结果的任务：
当你需要在任务执行后获得一个结果时，使用Callable比Runnable更合适。例如，计算某个值并返回。
需要处理异常的任务：
如果任务在执行过程中可能抛出异常，并且你需要捕获和处理这些异常，Callable接口比Runnable更合适。
并行计算和聚合结果：
在并行计算场景中，你可以使用多个Callable任务并行执行，并在所有任务完成后收集结果。

示例代码

使用Callable执行任务并返回结果

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableExample {
    public static void main(String[] args) {
        // 创建一个ExecutorService实例
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 创建一个Callable任务
        Callable<Integer> task = () -> {
            // 模拟长时间的计算
            Thread.sleep(2000);
            return 123;
        };

        // 提交Callable任务并获得Future对象
        Future<Integer> future = executor.submit(task);

        try {
            // 阻塞并等待任务完成，然后获取结果
            Integer result = future.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭ExecutorService
            executor.shutdown();
        }
    }
}

并行执行多个Callable任务并聚合结果

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ParallelCallableExample {
    public static void main(String[] args) {
        // 创建一个ExecutorService实例
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 创建多个Callable任务
        List<Callable<Integer>> tasks = Arrays.asList(
            () -> {
                Thread.sleep(1000);
                return 1;
            },
            () -> {
                Thread.sleep(2000);
                return 2;
            },
            () -> {
                Thread.sleep(3000);
                return 3;
            }
        );

        try {
            // 并行执行所有Callable任务并获得结果列表
            List<Future<Integer>> futures = executor.invokeAll(tasks);

            // 聚合结果
            for (Future<Integer> future : futures) {
                System.out.println("Result: " + future.get());
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭ExecutorService
            executor.shutdown();
        }
    }
}