Runnable 和 Callable 接口有什么区别？-java教程-PHP中文网

Runnable 无返回值且不能抛出受检查异常，适用于无需结果的后台任务；Callable 可返回结果并抛出异常，需结合 Future 获取结果和处理异常，适用于需要反馈的场景。

runnable 和 callable 接口有什么区别？

Runnable

登录后复制

和

Callable

登录后复制

接口在 Java 的多线程编程中都用于定义可执行的任务，但它们之间存在几个核心差异：

Runnable

登录后复制

接口的任务无法返回执行结果，也无法抛出受检查异常；而

Callable

登录后复制

接口的任务则可以返回一个结果，并且能够抛出受检查异常。简单来说，如果你只是想让一个任务在后台跑起来，不关心它的具体产出，

Runnable

登录后复制

就够了；但如果你需要任务执行完毕后给你一个明确的反馈（比如一个计算结果或一个操作状态），或者你需要更细致地处理任务中可能出现的错误，那么

Callable

登录后复制

则是更合适的选择。

解决方案

理解

Runnable

登录后复制

和

Callable

登录后复制

的区别，关键在于它们的接口定义和使用场景。

Runnable

登录后复制

接口非常简洁，它只有一个

run()

登录后复制

方法：

public interface Runnable {
    public abstract void run();
}

登录后复制

这个

run()

登录后复制

方法的特点是：

无返回值 (void)：
```
run()
```
登录后复制
方法不返回任何值。这意味着如果你需要从线程中获取计算结果，必须通过共享变量、回调机制或其他更复杂的方式来实现。
不抛出受检查异常：
```
run()
```
登录后复制
方法的签名中没有
```
throws Exception
```
登录后复制
。如果任务执行过程中可能抛出受检查异常（如
```
IOException
```
登录后复制
），你必须在
```
run()
```
登录后复制
方法内部捕获并处理它，或者将其包装成一个运行时异常 (
```
RuntimeException
```
登录后复制
) 抛出。

Callable

登录后复制

接口则相对复杂一些，它引入了泛型，并且只有一个

call()

登录后复制

方法：

public interface Callable<V> {
    V call() throws Exception;
}

登录后复制

call()

登录后复制

方法的特点是：

有返回值 (V)：
```
call()
```
登录后复制
方法可以返回一个泛型类型
```
V
```
登录后复制
的结果。这使得从异步任务中获取结果变得非常直接和方便。
可以抛出受检查异常：
```
call()
```
登录后复制
方法允许抛出
```
Exception
```
登录后复制
。这意味着你可以在任务内部抛出各种受检查异常，然后由调用者（通常是
```
ExecutorService
```
登录后复制
和
```
Future
```
登录后复制
）来捕获和处理这些异常，这让错误处理逻辑更加清晰和健鲁。

在我看来，

Runnable

登录后复制

更像是一个“执行指令”，你告诉它去做什么，它就去做了，至于结果如何，你得自己想办法去观察。而

Callable

登录后复制

则更像是一个“带报告的任务”，它不仅会执行你交代的任务，完成后还会给你一份详细的报告（返回值），甚至会告诉你执行过程中遇到了什么问题（抛出异常）。

实际使用中，

Runnable

登录后复制

常常与

Thread

登录后复制

类直接配合使用，或者在

ExecutorService

登录后复制

中作为“火并忘记”（fire-and-forget）的任务提交。而

Callable

登录后复制

几乎总是与

ExecutorService

登录后复制

框架结合使用，通过

submit()

登录后复制

方法提交任务，并返回一个

Future

登录后复制

对象来获取结果和管理任务状态。

为什么Java会引入

Callable

登录后复制

，

Runnable

登录后复制

不够用吗？

这个问题我经常被问到，也常常思考。在我看来，Java 引入

Callable

登录后复制

并非说

Runnable

登录后复制

“不够用”，而是为了解决

Runnable

登录后复制

在某些场景下的局限性，从而提供一种更优雅、更符合现代并发编程需求的方式。

Runnable

登录后复制

确实很经典，它在 Java 1.0 就已经存在，设计初衷就是为了定义一个独立的执行单元。但随着软件系统复杂度的提升，我们对并发任务的需求也变得多样化。最突出的两点就是：

无法直接获取任务结果：这是
```
Runnable
```
登录后复制
最大的痛点。设想一下，你启动了一个线程去执行一个复杂的计算，比如从数据库查询数据并进行统计分析。如果用
```
Runnable
```
登录后复制
，你得在
```
run()
```
登录后复制
方法内部把结果存到一个共享变量里，然后主线程再想办法去读取。这不仅需要额外的同步机制来保证数据可见性和线程安全（比如
```
volatile
```
登录后复制
关键字或者
```
synchronized
```
登录后复制
块），还会让代码变得复杂，容易出错。我个人觉得，这种“曲线救国”的方式，在很多时候确实显得笨拙。
受检查异常处理的限制：
```
run()
```
登录后复制
方法不允许抛出受检查异常。这意味着，如果你的任务在执行过程中可能遇到像
```
FileNotFoundException
```
登录后复制
、
```
SQLException
```
登录后复制
这样的异常，你必须在
```
run()
```
登录后复制
方法内部用
```
try-catch
```
登录后复制
块把它们全部消化掉。这导致了两种不理想的情况：
- 异常被吞噬：如果只是简单地打印日志，而没有向上层抛出，调用者可能根本不知道任务失败了。
- 异常包装：为了向上层传递异常信息，你可能需要将受检查异常包装成
```
RuntimeException
```
  登录后复制
  抛出，但这又失去了受检查异常的编译时检查优势，让错误处理变得隐晦。

Callable

登录后复制

的出现，正是为了直接解决这些问题。它引入了返回值和异常抛出机制，与

ExecutorService

登录后复制

和

Future

登录后复制

配合，形成了一套完整的异步任务管理方案。这套方案使得并发编程在获取结果和处理异常方面变得更加直观和强大。可以说，

Callable

登录后复制

并不是要替代

Runnable

登录后复制

，而是对

Runnable

登录后复制

在特定场景下的一个重要补充和功能增强。

Text-To-Pokemon口袋妖怪

输入文本生成自己的Pokemon，还有各种选项来定制自己的口袋妖怪

查看详情

在实际项目中，我应该如何选择使用

Runnable

登录后复制

还是

Callable

登录后复制

？

选择

Runnable

登录后复制

还是

Callable

登录后复制

，在我看来，主要取决于你的任务需求以及你对任务执行结果和异常处理的关注程度。没有绝对的优劣，只有最适合的场景。

关注点是“执行”而非“结果”时，选择
```
Runnable
```
登录后复制
。
- 场景示例：你只是想在后台执行一个操作，比如记录日志、发送邮件、更新缓存，或者启动一个独立的后台服务。这些任务的特点是，你通常不关心它们执行后会返回什么具体的值，只要它们能顺利执行就行。
- 我的理解：这就像你雇佣了一个工人去做清洁，你只关心他把活干了，至于他用什么工具、具体怎么擦的，你可能不太在意。对于这类任务，
```
Runnable
```
  登录后复制
  的简洁性是优势，没有不必要的泛型和返回值处理，代码会更轻量。
需要获取任务的计算结果，或者需要处理任务抛出的特定异常时，选择
```
Callable
```
登录后复制
。
- 场景示例：你需要从远程 API 获取数据、执行一个复杂的数学计算、处理一个大文件并返回处理摘要，或者并行执行多个子任务并汇总它们的结果。这些任务都需要一个明确的输出。
- 我的理解：这就像你请了一个专家去分析市场数据，你不仅希望他完成分析，更重要的是，你需要他给你一份详细的报告（返回值），并且如果分析过程中遇到什么无法解决的难题（异常），你希望他能明确告诉你，而不是默默地失败。
```
Callable
```
  登录后复制
  结合
```
Future
```
  登录后复制
  接口，能够让你优雅地获取异步任务的结果，并以结构化的方式处理可能发生的异常。

一个经验法则：

如果你的任务只是执行一个动作，没有明确的返回值需求，并且内部的异常可以自行处理或转换为运行时异常，那就用
```
Runnable
```
登录后复制
。
如果你的任务会产生一个有用的结果，或者你希望能够捕获并处理任务执行过程中可能抛出的受检查异常，那么
```
Callable
```
登录后复制
几乎是唯一的选择。

我发现很多新手会倾向于无脑使用

Callable

登录后复制

，觉得它更“高级”。但实际上，如果你的任务确实不需要返回值，用

Runnable

登录后复制

反而能让代码更清晰，避免引入不必要的复杂性。当然，两者都可以通过

ExecutorService.submit()

登录后复制

方法提交，即使是

Runnable

登录后复制

提交后也会返回一个

Future<?>

登录后复制

，但这个

Future

登录后复制

只能用于检查任务状态和取消任务，无法获取具体的计算结果。

Future

登录后复制

接口在处理

Callable

登录后复制

任务中扮演了什么角色？能给我一个简单的代码示例吗？

Future

登录后复制

接口在处理

Callable

登录后复制

任务中扮演着一个至关重要的角色，它就像是

Callable

登录后复制

任务的“代理”或者“承诺书”。当我们将一个

Callable

登录后复制

任务提交给

ExecutorService

登录后复制

后，

ExecutorService

登录后复制

会立即返回一个

Future

登录后复制

对象，而不会等待任务实际完成。这个

Future

登录后复制

对象代表了异步计算的结果，它提供了一系列方法来管理和查询这个异步任务的状态，并最终获取其结果。

具体来说，

Future

登录后复制

接口主要提供了以下功能：

检查任务状态：
```
isDone()
```
登录后复制
方法可以查询任务是否已经完成。
```
isCancelled()
```
登录后复制
方法可以查询任务是否已被取消。
取消任务：
```
cancel(boolean mayInterruptIfRunning)
```
登录后复制
方法可以尝试取消正在执行的任务。
获取任务结果：
```
get()
```
登录后复制
方法是
```
Future
```
登录后复制
最核心的功能。它会阻塞当前线程，直到
```
Callable
```
登录后复制
任务执行完毕并返回结果。如果任务执行过程中抛出了异常，那么
```
get()
```
登录后复制
方法也会抛出
```
ExecutionException
```
登录后复制
，通过
```
getCause()
```
登录后复制
可以获取到原始的异常。此外，还有一个
```
get(long timeout, TimeUnit unit)
```
登录后复制
方法，允许你在指定时间内等待结果，超时则抛出
```
TimeoutException
```
登录后复制
。

在我看来，

Future

登录后复制

的引入，真正让异步编程变得“可控”。它把异步任务的执行和结果的获取解耦开来，让我们可以灵活地在需要的时候去“兑现”这个承诺。

下面是一个简单的代码示例，展示了如何使用

Callable

登录后复制

和

Future

登录后复制

来执行一个异步计算并获取结果：

import java.util.concurrent.*;

// 1. 定义一个实现 Callable 接口的任务
class SummingTask implements Callable<Integer> {
    private final int start;
    private final int end;

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

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " 开始计算 " + start + " 到 " + end 的和...");
        int sum = 0;
        for (int i = start; i <= end; i++) {
            sum += i;
            // 模拟耗时操作，或者引入一个随机的异常
            if (i == start + 5 && Math.random() < 0.2) { // 大约20%的几率抛出异常
                throw new IllegalStateException("模拟计算过程中发生了一个错误，例如数据不一致。");
            }
            Thread.sleep(10); // 每次加法后暂停一小会儿
        }
        System.out.println(Thread.currentThread().getName() + " 计算完成，结果: " + sum);
        return sum;
    }
}

public class CallableFutureExample {
    public static void main(String[] args) {
        // 2. 创建一个 ExecutorService 来管理和执行任务
        // 这里使用固定大小的线程池，实际项目中可以根据需求选择不同类型的线程池
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 3. 创建 Callable 任务实例
        Callable<Integer> task1 = new SummingTask(1, 10);
        Callable<Integer> task2 = new SummingTask(11, 20);
        Callable<Integer> task3 = new SummingTask(21, 30); // 增加一个可能抛出异常的任务

        // 4. 提交 Callable 任务到 ExecutorService，并获取 Future 对象
        Future<Integer> future1 = executor.submit(task1);
        Future<Integer> future2 = executor.submit(task2);
        Future<Integer> future3 = executor.submit(task3); // 提交可能失败的任务

        System.out.println("所有任务已提交，主线程继续执行其他操作...");

        try {
            // 5. 通过 Future 对象获取任务结果，get() 方法会阻塞直到任务完成
            System.out.println("尝试获取 task1 的结果...");
            Integer result1 = future1.get(); // 可能会阻塞
            System.out.println("Task 1 的结果是: " + result1);

            System.out.println("尝试获取 task2 的结果...");
            Integer result2 = future2.get(5, TimeUnit.SECONDS); // 最多等待5秒
            System.out.println("Task 2 的结果是: " + result2);

            System.out.println("尝试获取 task3 的结果...");
            // 如果 task3 抛出了异常，get() 会抛出 ExecutionException
            Integer result3 = future3.get();
            System.out.println("Task 3 的结果是: " + result3);

        } catch (InterruptedException e) {
            // 当前线程在等待结果时被中断
            Thread.currentThread().interrupt(); // 重新设置中断标志
            System.err.println("主线程在等待结果时被中断: " + e.getMessage());
        } catch (ExecutionException e) {
            // Callable 任务内部抛出的异常会被封装在 ExecutionException 中
            System.err.println("任务执行失败: " + e.getCause().getMessage());
            e.getCause().printStackTrace(); // 打印原始异常堆栈
        } catch (TimeoutException e) {
            // get(timeout, unit) 方法超时
            System.err.println("获取任务结果超时: " + e.getMessage());
            // 此时可以选择取消任务
            future2.cancel(true);
        } finally {
            // 6. 关闭 ExecutorService
            executor.shutdown();
            try {
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    executor.shutdownNow(); // 强制关闭
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
            System.out.println("ExecutorService 已关闭。");
        }
    }
}

登录后复制

在这个例子中，