编辑“︁Java Callable接口”︁（章节）

= Java Callable接口 =

'''Java Callable接口'''是Java多线程编程中的一个核心接口，用于定义可以返回结果并可能抛出异常的任务。它与[[Runnable]]接口类似，但提供了更强大的功能，允许线程在执行完成后返回计算结果，并支持异常处理。Callable通常与[[ExecutorService]]结合使用，通过[[Future]]对象获取异步计算结果。

== 介绍 ==

Callable接口定义在`java.util.concurrent`包中，其泛型形式为`Callable<V>`，其中`V`表示任务返回的结果类型。与`Runnable`不同，`Callable`的`call()`方法可以返回结果并抛出受检异常。

=== 接口定义 ===
<syntaxhighlight lang="java">
public interface Callable<V> {
    V call() throws Exception;
}
</syntaxhighlight>

== 与Runnable的区别 ==

{| class="wikitable"
|-
! 特性 !! Callable !! Runnable
|-
| 返回值 | 支持（泛型） | 不支持（void）
|-
| 异常处理 | 可以抛出受检异常 | 不能抛出受检异常
|-
| 使用场景 | 需要返回结果的任务 | 不需要返回结果的任务
|}

== 基本用法 ==

=== 示例1：简单Callable实现 ===
以下示例展示如何创建并执行一个返回字符串的Callable任务：

<syntaxhighlight lang="java">
import java.util.concurrent.*;

public class CallableExample {
    public static void main(String[] args) throws Exception {
        // 创建Callable任务
        Callable<String> task = () -> {
            Thread.sleep(1000); // 模拟耗时操作
            return "Hello from Callable!";
        };

        // 使用ExecutorService执行
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(task);

        // 获取结果（阻塞直到完成）
        String result = future.get();
        System.out.println(result); // 输出: Hello from Callable!

        executor.shutdown();
    }
}
</syntaxhighlight>

=== 输出 ===
<pre>
Hello from Callable!
</pre>

== Future与Callable ==

Callable通常与Future配合使用，Future表示异步计算的结果。关键方法包括：

* `get()`：获取结果（阻塞）
* `isDone()`：检查任务是否完成
* `cancel(boolean mayInterruptIfRunning)`：尝试取消任务

=== 示例2：带超时的Future ===
<syntaxhighlight lang="java">
Future<String> future = executor.submit(task);
try {
    // 设置2秒超时
    String result = future.get(2, TimeUnit.SECONDS);
    System.out.println(result);
} catch (TimeoutException e) {
    System.err.println("任务超时");
    future.cancel(true); // 中断任务
}
</syntaxhighlight>

== 异常处理 ==

Callable可以抛出异常，这些异常会通过Future.get()传播：

<syntaxhighlight lang="java">
Callable<Integer> task = () -> {
    if (Math.random() > 0.5) {
        throw new IOException("模拟I/O异常");
    }
    return 42;
};

Future<Integer> future = executor.submit(task);
try {
    Integer result = future.get();
} catch (ExecutionException e) {
    Throwable cause = e.getCause();
    if (cause instanceof IOException) {
        System.err.println("捕获到IO异常: " + cause.getMessage());
    }
}
</syntaxhighlight>

== 实际应用案例 ==

=== 案例：并行计算 ===
使用Callable实现并行计算斐波那契数列：

<syntaxhighlight lang="java">
public class FibonacciCalculator {
    static class FibonacciTask implements Callable<Long> {
        private final int n;
        
        FibonacciTask(int n) { this.n = n; }
        
        @Override
        public Long call() {
            return compute(n);
        }
        
        private long compute(int n) {
            if (n <= 1) return n;
            return compute(n-1) + compute(n-2);
        }
    }

    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        List<Future<Long>> results = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            results.add(executor.submit(new FibonacciTask(i)));
        }
        
        for (Future<Long> future : results) {
            System.out.println(future.get());
        }
        
        executor.shutdown();
    }
}
</syntaxhighlight>

=== 输出 ===
<pre>
0
1
1
2
3
5
8
13
21
34
</pre>

== 高级主题 ==

=== 任务取消 ===
使用Future.cancel()可以中断正在执行的任务：

<mermaid>
sequenceDiagram
    participant Main
    participant Executor
    participant Worker
    
    Main->>Executor: submit(Callable)
    Executor->>Worker: 启动线程执行call()
    Main->>Future: cancel(true)
    Future->>Worker: 中断线程
    Worker-->>Future: 抛出InterruptedException
</mermaid>

=== CompletionService ===
当需要按完成顺序处理结果时，可以使用CompletionService：

<syntaxhighlight lang="java">
ExecutorService executor = Executors.newFixedThreadPool(4);
CompletionService<String> completionService = new ExecutorCompletionService<>(executor);

// 提交多个任务
completionService.submit(() -> "Task1");
completionService.submit(() -> "Task2");

// 按完成顺序获取结果
for (int i = 0; i < 2; i++) {
    Future<String> completedFuture = completionService.take();
    System.out.println(completedFuture.get());
}
</syntaxhighlight>

== 性能考虑 ==

* 线程池大小应根据任务类型（CPU密集型/IO密集型）合理配置
* 避免在call()方法中执行阻塞操作（除非使用特定线程池）
* 大量小任务可考虑使用ForkJoinPool

== 数学表示 ==

对于并行计算任务，假设有<math>n</math>个独立任务，总执行时间<math>T</math>可表示为：

<math>
T = \max(T_1, T_2, ..., T_n)
</math>

其中<math>T_i</math>是第<math>i</math>个任务的执行时间。

== 总结 ==

Java Callable接口提供了比Runnable更强大的任务定义方式，支持：
* 返回值
* 异常传播
* 与Future/ExecutorService集成
* 任务取消机制

它是构建复杂异步应用程序的基础组件，特别适用于需要结果返回的并行计算场景。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java多线程]]