使用 java.util.concurrent.Callable 接口可以编写支持泛型返回值的多线程任务。以下是详细步骤和示例代码：1. 定义 Callable 任务Callable 是一个带有泛型参数的接口，允许你指定任务执行后的返回类型。import java.util.concurrent.Callable; public class MyTask implements Callable<

Java 中的 `Callable` 接口是 `Runnable` 的增强替代方案，它通过泛型支持任意类型的返回值（如 String、Integer 或自定义对象），并允许抛出受检异常，配合 `ExecutorService` 的 `submit()` 方法可轻松提交异步任务，再通过 `Future` 获取结果、处理超时与异常，甚至批量执行多个任务（如 `invokeAll`），让多线程编程既安全又灵活——无论你是需要计算结果、查询数据还是组合多个异步操作，`Callable` 都能优雅支撑。

Callable 是 Java 并发包中用于替代 Runnable 的接口，核心优势在于它支持返回值和抛出受检异常。它天然支持泛型，通过类型参数 V 指定返回值类型，配合 ExecutorService 可以轻松实现带结果的多线程任务。

定义泛型 Callable 任务

直接实现 Callable 接口，其中 V 是你期望的返回类型（如 String、Integer、自定义对象等）。重写 call() 方法，在其中编写耗时逻辑并返回对应类型的值：

Callable<Integer> task = () -> {
    Thread.sleep(1000); // 模拟耗时操作
    return 42; // 返回 Integer 类型值
};

也可以写成独立类形式，便于复用和测试：

public class SumTask implements Callable<Long> {
    private final int start, end;

    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    public Long call() throws Exception {
        long sum = 0;
        for (int i = start; i <= end; i++) {
            sum += i;
        }
        return sum; // 自动装箱为 Long
    }
}

提交任务并获取泛型返回结果

使用 ExecutorService.submit() 提交 Callable，它会立即返回一个 Future。这个 Future 的泛型类型与 Callable 一致，编译器能准确推断，无需强制转换：

ExecutorService executor = Executors.newFixedThreadPool(2);

// 提交任务，得到 Future<Integer>
Future<Integer> future = executor.submit(task);

try {
    Integer result = future.get(); // 阻塞等待，返回 Integer 类型
    System.out.println("Result: " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

executor.shutdown();

批量提交多种泛型 Callable 并安全收集结果

当需要并行执行多个不同返回类型的任务（比如一个查数据库返回 User，一个调用 API 返回 Order），可分别定义对应泛型的 Callable，统一用 invokeAll() 或逐个 submit()：

• 每个 Callable 独立声明自己的泛型，互不影响
• 推荐用 List> 存储结果，避免类型擦除导致的隐患
• 调用 future.get() 时，返回值类型由泛型声明保证，IDE 和编译器全程校验

Callable<User> userTask = () -> fetchUserById(123);
Callable<List<Order>> orderTask = () -> fetchOrdersByUserId(123);

List<Future<?>> futures = executor.invokeAll(
    Arrays.asList(userTask, orderTask)
);

// 分别获取（注意类型安全）
User user = ((Future<User>) futures.get(0)).get();
List<Order> orders = ((Future<List<Order>>) futures.get(1)).get();

处理异常与超时更安全

Callable.call() 允许抛出任意异常（包括受检异常），这些异常会被包装进 ExecutionException，在 future.get() 中统一抛出。建议显式处理：

• 用 future.get(timeout, unit) 避免无限等待
• 捕获 ExecutionException 获取原始异常（e.getCause()）
• 捕获 TimeoutException 和 CancellationException 做针对性处理

try {
    String result = future.get(3, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    System.err.println("Task timed out");
    future.cancel(true); // 中断执行线程
} catch (ExecutionException e) {
    Throwable cause = e.getCause();
    System.err.println("Task failed: " + cause.getMessage());
}

本篇关于《使用 java.util.concurrent.Callable 接口可以编写支持泛型返回值的多线程任务。以下是详细步骤和示例代码：1. 定义 Callable 任务Callable 是一个带有泛型参数的接口，允许你指定任务执行后的返回类型。import java.util.concurrent.Callable; public class MyTask implements Callable { @Override public String call() throws Exception { // 模拟耗时操作 Thread.sleep(2000); return "任务执行完成"; } }2. 使用 ExecutorService 提交任务通过 ExecutorService 提交 Callable 任务，并获取结果。import java.util.concurrent.*; public class Main { public static void main(String[] args) { ExecutorService executor = Executors.newSingleThreadExecutor(); Callable task = new MyTask(); try { Future future = executor.submit(task); String result = future.get(); // 获取任务返回值 System.out.println(result); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } finally { executor.shutdown(); } } }3. 处理异常与超时（可选）你可以设置超时时间，防止任务长时间阻塞。 try { String result = future.get(5》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！