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

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

除了所有其他答案:

我们不能传递/使用Callable到单独的线程执行，即Callable只能在执行器框架中使用。 但是，Runnable可以传递给一个单独的线程执行(new thread (new CustomRunnable()))，也可以在Executor Framework中使用。

当我们使用Executer框架时，Runnable (vs) Callable就出现了。

ExecutorService是Executor的子接口，它接受可运行任务和可调用任务。

早期的多线程可以使用Interface RunnableSince 1.0实现，但这里的问题是在完成线程任务后，我们无法收集线程信息。为了收集数据，我们可以使用静态字段。

使用不同的线程收集每个学生的数据。

static HashMap<String, List> multiTasksData = new HashMap();
public static void main(String[] args) {
    Thread t1 = new Thread( new RunnableImpl(1), "T1" );
    Thread t2 = new Thread( new RunnableImpl(2), "T2" );
    Thread t3 = new Thread( new RunnableImpl(3), "T3" );

    multiTasksData.put("T1", new ArrayList() ); // later get the value and update it.
    multiTasksData.put("T2", new ArrayList() );
    multiTasksData.put("T3", new ArrayList() );
}

为了解决这个问题，他们引入了Callable<V>Since 1.5，它返回一个结果并可能引发异常。

单一抽象方法:可调用接口和可运行接口都有一个单一的抽象方法，这意味着它们可以在java 8的lambda表达式中使用。 可运行的{ 公共无效运行(); } 可调用的<对象> { 公共对象调用()抛出异常; ｝

有几种不同的方法可以将任务委托给ExecutorService执行。

execute(可运行任务):void将新线程装箱，但不会阻塞主线程或调用线程，因为此方法返回void。 未来提交(可调用< ? >):< ?未来>,提交(Runnable): < ?当你使用future.get()时，>板条箱新线程并阻塞主线程。

在Executor框架中使用可运行、可调用接口的例子。

class CallableTask implements Callable<Integer> {
    private int num = 0;
    public CallableTask(int num) {
        this.num = num;
    }
    @Override
    public Integer call() throws Exception {
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName + " : Started Task...");

        for (int i = 0; i < 5; i++) {
            System.out.println(i + " : " + threadName + " : " + num);
            num = num + i;
            MainThread_Wait_TillWorkerThreadsComplete.sleep(1);
        }
        System.out.println(threadName + " : Completed Task. Final Value : "+ num);

        return num;
    }
}
class RunnableTask implements Runnable {
    private int num = 0;
    public RunnableTask(int num) {
        this.num = num;
    }
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName + " : Started Task...");

        for (int i = 0; i < 5; i++) {
            System.out.println(i + " : " + threadName + " : " + num);
            num = num + i;
            MainThread_Wait_TillWorkerThreadsComplete.sleep(1);
        }
        System.out.println(threadName + " : Completed Task. Final Value : "+ num);
    }
}
public class MainThread_Wait_TillWorkerThreadsComplete {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("Main Thread start...");
        Instant start = java.time.Instant.now();

        runnableThreads();
        callableThreads();

        Instant end = java.time.Instant.now();
        Duration between = java.time.Duration.between(start, end);
        System.out.format("Time taken : %02d:%02d.%04d \n", between.toMinutes(), between.getSeconds(), between.toMillis()); 

        System.out.println("Main Thread completed...");
    }
    public static void runnableThreads() throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        Future<?> f1 = executor.submit( new RunnableTask(5) );
        Future<?> f2 = executor.submit( new RunnableTask(2) );
        Future<?> f3 = executor.submit( new RunnableTask(1) );

        // Waits until pool-thread complete, return null upon successful completion.
        System.out.println("F1 : "+ f1.get());
        System.out.println("F2 : "+ f2.get());
        System.out.println("F3 : "+ f3.get());

        executor.shutdown();
    }
    public static void callableThreads() throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        Future<Integer> f1 = executor.submit( new CallableTask(5) );
        Future<Integer> f2 = executor.submit( new CallableTask(2) );
        Future<Integer> f3 = executor.submit( new CallableTask(1) );

        // Waits until pool-thread complete, returns the result.
        System.out.println("F1 : "+ f1.get());
        System.out.println("F2 : "+ f2.get());
        System.out.println("F3 : "+ f3.get());

        executor.shutdown();
    }
}

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

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

Runnable和Callable在应用程序中的区别是什么?是否只与返回参数在Callable中存在差异?

基本上,是的。请看这个问题的答案。Callable的javadoc。

如果Callable能做Runnable能做的所有事情，那么两者都需要什么呢?

因为Runnable接口不能做Callable所做的所有事情!

Runnable has been around since Java 1.0, but Callable was only introduced in Java 1.5 ... to handle use-cases that Runnable does not support. In theory, the Java team could have changed the signature of the Runnable.run() method, but this would have broken binary compatiblity with pre-1.5 code, requiring recoding when migrating old Java code to newer JVMs. That is a BIG NO-NO. Java strives to be backwards compatible ... and that's been one of Java's biggest selling points for business computing.

显然，在某些用例中，任务不需要返回结果或抛出检查过的异常。对于这些用例，使用Runnable比使用Callable<Void>和从call()方法返回一个虚拟(null)值更简洁。

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