Callable和Runnable之间的区别如下:

在JDK 5.0中引入了Callable，而在JDK 1.0中引入了Runnable 可调用对象有call()方法，而Runnable有run()方法。 可调用对象有返回值的call方法，而可运行对象有不返回任何值的run方法。 调用方法可以抛出检查异常，但运行方法不能抛出检查异常。 可调用的使用submit()方法放入任务队列，可运行的使用execute()方法放入任务队列。

可调用接口声明call()方法，您需要提供泛型类型的对象call()应该返回-

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

另一方面，Runnable是一个接口，它声明了run()方法，当你创建一个带有Runnable的线程并在其上调用start()时，该方法将被调用。你也可以直接调用run()，但这只是执行run()方法是同一个线程。

public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used 
     * to create a thread, starting the thread causes the object's 
     * <code>run</code> method to be called in that separately executing 
     * thread. 
     * <p>
     * The general contract of the method <code>run</code> is that it may 
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

综上所述，有几个显著的差异

Runnable对象不返回结果，而Callable对象返回结果。 Runnable对象不能抛出检查异常，而Callable对象可以抛出检查异常 例外。 Runnable接口从Java 1.0开始就已经存在了，而Callable只是被引入的 在Java 1.5中。

相似之处包括

实现Runnable或Callable接口的类实例是潜在的 由另一个线程执行。 可调用接口和可运行接口的实例都可以由ExecutorService通过submit()方法执行。 两者都是功能接口，从Java8开始就可以在Lambda表达式中使用。

ExecutorService接口中的方法是

<T> Future<T> submit(Callable<T> task);
Future<?> submit(Runnable task);
<T> Future<T> submit(Runnable task, T result);

oracle文档中这些接口的用途:

可运行接口应该由任何类实现，其实例将由线程执行。该类必须定义一个名为run的无参数方法。

可调用:返回结果并可能抛出异常的任务。实现者定义一个不带参数的方法叫做call。 Callable接口与Runnable接口类似，因为两者都是为其实例可能由另一个线程执行的类设计的。然而，Runnable不返回结果，也不能抛出受控异常。

其他的差异:

You can pass Runnable to create a Thread. But you can't create new Thread by passing Callable as parameter. You can pass Callable only to ExecutorService instances. Example: public class HelloRunnable implements Runnable { public void run() { System.out.println("Hello from a thread!"); } public static void main(String args[]) { (new Thread(new HelloRunnable())).start(); } } Use Runnable for fire and forget calls. Use Callable to verify the result. Callable can be passed to invokeAll method unlike Runnable. Methods invokeAny and invokeAll perform the most commonly useful forms of bulk execution, executing a collection of tasks and then waiting for at least one, or all, to complete Trivial difference : method name to be implemented => run() for Runnable and call() for Callable.

Callable需要实现call()方法，而Runnable需要实现run()方法。 Callable可以返回值，但Runnable不能。 Callable可以抛出受控异常，但Runnable不能。 可调用对象可以与ExecutorService#invokeXXX(Collection<?扩展Callable<T>> tasks)方法，但Runnable不能。 可运行的{ 空运行(); ｝ 可调用接口<V> { V call()抛出异常; ｝

让我们看看在哪里可以使用Runnable和Callable。

Runnable和Callable都运行在与调用线程不同的线程上。但是Callable可以返回值，而Runnable不能。那么这到底适用于什么呢?

Runnable:如果你有一个火和忘记任务，那么使用Runnable。将代码放在Runnable中，当run()方法被调用时，就可以执行任务了。调用线程实际上并不关心您何时执行任务。

Callable:如果您试图从任务中检索值，则使用Callable。可调用本身是做不到的。你将需要一个Future，你将它包裹在你的Callable中，并获得关于Future的价值。get()。在这里，调用线程将被阻塞，直到Future返回结果，然后等待Callable的call()方法执行。

因此，考虑一个到目标类的接口，其中定义了Runnable和Callable包装方法。调用类会随机调用你的接口方法，不知道哪个是Runnable，哪个是Callable。Runnable方法将异步执行，直到Callable方法被调用。这里调用类的线程将阻塞，因为您正在从目标类中检索值。

注意:在目标类内部，您可以在单个线程执行器上调用Callable和Runnable，使此机制类似于串行调度队列。因此，只要调用者调用你的Runnable包装方法，调用线程就会非常快地执行而不会阻塞。一旦它调用了一个包装在Future方法中的Callable，它将不得不阻塞，直到所有其他排队的项都被执行。只有这样，该方法才会返回值。这是一种同步机制。

请看这里的解释。

Callable接口类似于 可运行的，因为两者都是设计出来的 对于实例为的类 可能由另一个人执行 线程。然而，Runnable则不然 返回结果，且不能抛出 检查异常。