Java中除了Runnable介面，還有Callable介面。
兩者區別是，後者可以有返回值，一般用於耗時計算。
Runnable介面線上程中用得比較多，一般可以作為執行緒執行體，Callable一般會與FutureTask結合使用。

Callable介面的原始碼如下：

/**
 * A task that returns a result and may throw an exception.
 * Implementors define a single method with no arguments called
 * {@code call}.
 * 帶有返回值的任務，可能丟擲異常。
 * 
 * <p>The {@code Callable} interface is similar to {@link
 * java.lang.Runnable}, in that both are designed for classes whose
 * instances are potentially executed by another thread.  A
 * {@code Runnable}, however, does not return a result and cannot
 * throw a checked exception.
 * Callable介面類似於Runnable介面，都是設計用於被其他執行緒執行的類例項。
 * 但是Runnable介面不返回結果，不能丟擲一個受檢異常。
 * 
 * <p>The {@link Executors} class contains utility methods to
 * convert from other common forms to {@code Callable} classes.
 * Executors類包含將其他通用形式轉成Callable類的輔助類。
 * 
 * @see
 
 Executor
 * @since 1.5
 * @author Doug Lea
 * @param <V> the result type of method {@code call}
 */
@FunctionalInterface
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;
}

Future介面用於表示非同步計算的結果，該介面包含檢查計算是否結束、等待計算結束、獲取計算結果的方法。
其中get()可以獲取計算結果，在計算完成之前，會一直阻塞當前執行緒。計算可以被取消。

FutureTask實現了RunnableFuture介面：

public class FutureTask<V> implements RunnableFuture<V> {

而RunnableFuture介面繼承自Runnable和Future：

public interface RunnableFuture
 
<V> extends Runnable, Future<V> {

FutureTask表示可取消的非同步計算，作為Future介面的實現。FutureTask可以包裝Runnable介面，
另外因為實現了Runnable介面，所以可以提交給Executor執行。

下面用程式碼測試一下：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {

    Runnable runnable = new Runnable() {

        @Override
        public void run() {
        System.out.println("runnable running");
        }
    };

    Callable<Integer> callable = new Callable<Integer>() {

        @Override
        public Integer call() throws Exception {
        System.out.println("callable running");

        return 123;
        }
    };

    Callable<Integer> callable1 = new Callable<Integer>() {

        @Override
        public Integer call() throws Exception {
        System.out.println("callable1 running");

        return 123;
        }
    };

    //runnable
    Thread thread1 = new Thread(runnable);
    thread1.start();

    //callable
    FutureTask<Integer> future = new FutureTask<Integer>(callable);
    Thread thread2 = new Thread(future);
    thread2.start();

    System.out.println("future is done? "+future.isDone());
    //future.cancel(false);
    Thread.sleep(1000);
    System.out.println("future result: "+future.get());

    ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0L,
        TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

    executor.execute(runnable);

    FutureTask<Integer> future1 = new FutureTask<Integer>(callable1);
    executor.execute(future1);

    FutureTask<String> ft = new FutureTask<String>(runnable, "aaaaa");
    Thread thread3 = new Thread(ft);
    thread3.start();
    while(!ft.isDone()){
        Thread.sleep(1000);     
    }
    System.out.println("future runnable result: "+ft.get());

    Future<Integer> futureTask = executor.submit(callable);
    while(!futureTask.isDone()){
        Thread.sleep(1000);     
    }
    System.out.println("futureTask result: "+futureTask.get());
    executor.shutdown();


    }
}

輸出結果：

runnable running
future is done? false
callable running
future result: 123
runnable running
callable1 running
runnable running
future runnable result: aaaaa
callable running
futureTask result: 123