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和Runnable之间的区别如下:

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

正如这里已经提到的，Callable是一个相对较新的接口，它是作为并发包的一部分引入的。Callable和Runnable都可以与执行器一起使用。Thread类(实现Runnable本身)只支持Runnable。

您仍然可以将Runnable与执行程序一起使用。Callable的优点是，你可以将它发送给executor，并立即得到Future结果，当执行完成时，Future结果将被更新。Runnable也可以实现同样的功能，但在这种情况下，您必须自己管理结果。例如，您可以创建保存所有结果的结果队列。其他线程可以等待这个队列并处理到达的结果。

Java功能接口

它是一种与函数式编程相匹配的接口命名约定

//Runnable
interface Runnable {
    void run();
}

//Action - throws exception
interface Action {
    void run() throws Exception;
}

//Consumer - consumes a value/values, throws exception
//BiConsumer, 
interface Consumer1<T> {
    void accept(T t) throws Exception;
}

//Callable - return result, throws exception
interface Callable<R> {
    R call() throws Exception;
}

//Supplier - returns result, throws exception
interface Supplier<R> {
    R get() throws Exception;
}

//Predicate - consumes a value/values, returns true or false, throws exception
interface Predicate1<T> {
    boolean test(T t) throws Exception;
}

//Function - consumes a value/values, returns result, throws exception
//BiFunction, Function3...
public interface Function1<T, R> {
    R apply(T t) throws Exception;
}

...

//Executor
public interface Executor {
    void execute(Runnable command);
}

【快速闭包命名】

可调用接口声明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.