在哪里使用可调用以及在哪里使用Runnable接口？

Question

我是Java的新手，我正在阅读多线程的概念，在进行多线程的各种实现时，我经历了这两个概念。 这在Java问题中Runnable和Callable接口之间的区别指出了两者之间的区别以及使用的位置。

我怀疑Callable是否能够完成Runnable的所有功能，为什么这么多人使用Runnable而不是可调用？ 与Runnable Inteface相比，实现Callable接口是否有额外的开销？

Answer 1

在Java 5发行版中存在java.util.concurrent包之前，实际上没有其他选项可以进行并发计算，而是直接操作Thread 。

您可以直接操作线程，例如通过子类化：

public class MyThread extends Thread {
    public void run() {
        myComputation();
    }
}

或者你可以通过创建一个Runnable来做同样的事情，这是首选方式（主要是因为你不需要子类化任何东西，它提供了明确的关注点分离，更好的代码重用或一般来说，更好的组合）：

public class MyRunnable implements Runnable {
    public void run() {
        mycomputation();
    }
}
new Thread(new MyRunnable()).start();

但无论您使用哪种方式，都必须创建，启动，操作，加入线程。 哪个有缺点：你可以创建多少个线程？ 这个贵吗？ （在某些时候，它是，尽管每个JVM实现变得更便宜和更便宜。）

此外，这个API本身也有开发人员必须克服的限制：如果我想从Runnable返回一个值，看到签名不允许它怎么办？ 我怎么知道我的Runnable是否因Exception失败？ 有一些事情，例如异常处理程序等允许使用线程，但它是一个安静的重复，容易出错的任务。

进入java.util.concurrent包！ 它提供了所有这些（以及更多）的答案！

您希望为多个“工作单元”重用线程（无论是否为Runnable ？）：您可以。 想知道“工作单位”是否完成或失败：你可以。 想要返回一个值：你可以。 想要将某些任务动态优先于其他任务吗？ 当然。 需要能够安排任务吗？ 可以做。 等等。

用Callable替换你的Runnable （这很简单，两者都是单个方法接口！），停止操作Thread s以支持Future s并将管道保留给ExecutorService 。

我怀疑Callable是否能够完成Runnable的所有功能，为什么这么多人使用Runnable而不是可调用？

也许他们确实有旧代码（Java 1.4？）。 也许他们不了解更高级别抽象的好处，而更喜欢低级别的Thread东西？

一般来说，自从并发API出现以来，绝对没有理由更喜欢使用Thread 。

与Runnable接口相比，实现Callable接口是否有额外的开销？

在“实现Callable ”vs Runnable ，没有没有。 但是新的Callable的成本是有代价的，因为在内部，它都会回到Thread s和Runnable （至少，当前的实现会这样做）。 但是你可能实际上获得了性能，因为新的功能，比如更容易的线程重用！

所以，是的，并发API有它的成本，但它在任何标准用例中绝对，完全可以忽略不计，但它也有新的优势，使其在许多方面更好，包括性能。

此外，您已经从API中获得了大量新的可能性（参见Fork / Join框架，请参阅Java 8中的并行流，...），并减少对“自定义”，“自制”的任何扭结的需求“所述功能的并发代码，众所周知很难做到。

利益/成本比完全支持“新”并发API。

Answer 2

我怀疑Callable是否能够完成Runnable的所有功能，为什么这么多人使用Runnable而不是可调用？ 与Runnable Inteface相比，实现Callable接口是否有额外的开销？

1. 使用Runnable接口进行fire和forget调用，尤其是当您对任务执行结果不感兴趣时​​。
2. Callable接口的实现没有额外的开销。

与文档页面的主要区别

Callable接口类似于Runnable ，因为它们都是为其实例可能由另一个线程执行的类而设计的。 但是， Runnable不会返回结果，也不会抛出已检查的异常。

让我们检查一下AbstractExecutorService的源代码

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Object> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}


public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

我没有看到执行Callable任务的任何开销，因为Callable内部使用RunnableFuture<T>

Answer 3

一个重要的区别： Runnable接口中的run()方法返回void; Callable接口中的call()方法返回类型为T的对象。 这允许您轻松访问响应对象。

你可以通过创建一个私有数据成员并提供一个getter来对Runnable的具体实现做同样的事情，但语法糖很甜。

Answer 4

为什么这么多人使用Runnable而不是可调用？

Callable在jdk中具有竞争力，它与Executor框架一起提供，为线程执行提供了更大的灵活性。

与Runnable Inteface相比，实现Callable接口是否有额外的开销？

我不这么认为，如果您遵循任何标准的Executor文档，它是非常直接的。

Answer 5

我怀疑Callable是否能够完成Runnable的所有功能，为什么这么多人使用Runnable而不是可调用？

这个问题等于问“为什么Java有静态类型？” 接口是编译时类型签名的声明，仅此而已; 并且任何两个接口之间的唯一区别是参数的编译时类型和返回值。

那么为什么Java有静态类型呢？ 不幸的是，这个问题超出了StackOverflow的范围。 您可以使用Google查找有关静态类型语言与动态类型语言的所有信息。

此外，如果您想要了解不同的世界，您可以尝试编写一些Ruby代码。 Ruby中没有接口，因为没有静态类型。 Ruby程序员谈论“Duck Typing”，这是Google的另一个好词。