一般建立執行緒只有兩種方式，一種是繼承Thread，一種是實現Runnable介面。但是這兩種建立方式有一個致命的缺點就是沒有返回值，沒返回值就讓人很苦惱了啊。得用共享變數或者其他通訊方式才能得到執行緒處理完的結果，就有點麻煩。
還有一般不提倡使用繼承Thread來建立執行緒方式，因為Java只有單繼承，不能繼承多個。但是Runnable是介面，所以可以讓你的實現類同時實現多個介面。而且之後要上執行緒池，如果之前你是用Runnable來實現的，那就可以直接傳入Runnable給執行緒池進行管理了！
在Java1.5之後就有了Callable、Future。這二種可以提供執行緒執行完的結果！
接下來簡單介紹下Runnable、Callable 、Future、 FutureTask。
Runnable
Runnable 是一個介面，簡單就一個方法，實現run方法，在run方法裡面編寫你要執行的程式碼就行了，但是沒有任務返回介面，並且無法丟擲異常。
public interface Runnable {
public abstract void run();
}
複製程式碼簡單應用
Runnable runnable =
new Runnable() {
@Override
public void run() {
System.out.println("2333");
}
};
Thread thread = new Thread(runnable);
thread.start();
複製程式碼Callable
Callable也是一個介面，很簡單就一個call方法，在call方法裡面編寫你要執行的程式碼就行了，返回的就是執行的結果了。和Runnable 差別就是它有返回的結果，並且可以丟擲異常！一般配合ThreadPoolExecutor使用的。
public interface Callable<V> {
V call() throws Exception;
}
複製程式碼簡單應用,它不能直接配合Thread 使用。
Callable<String> callable =
new Callable<String>() {
@Override
public String call() throws Exception {
return "2333";
}
};
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<String> result = executor.submit(callable);
System.out.println(result.get());
複製程式碼Future
Future也是一個介面，它可以對具體的Runnable或者Callable任務進行取消、判斷任務是否已取消、查詢任務是否完成、獲取任務結果。如果是Runnable的話返回的結果是null(下面會剖析為什麼Runnable的任務，Future還能返回結果)。介面裡面有以下幾個方法。注意兩個get方法都會阻塞當前呼叫get的執行緒，直到返回結果或者超時才會喚醒當前的執行緒。
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning); // 取消任務
boolean isCancelled(); // 判斷任務是否已取消
boolean isDone(); // 判斷任務是否已結束
V get() throws InterruptedException, ExecutionException;// 獲得任務執行結果
// 獲得任務執行結果，支援超時
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}
複製程式碼簡單應用
Callable<String> callable =
new Callable<String>() {
@Override
public String call() throws Exception {
return "2333";
}
};
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<String> result = executor.submit(callable);
result.cancel(true);
System.out.println(result.isCancelled());
複製程式碼FutureTask
因為Future只是一個介面，所以是無法直接用來建立物件使用的，因此就有了下面的FutureTask。
FutureTask不是介面了，是個class。它實現了RunnableFuture介面
public class FutureTask<V> implements RunnableFuture<V>
而RunnableFuture介面又繼承了Runnable和Future
public interface RunnableFuture<V> extends Runnable, Future<V>
因此它可以作為Runnable被執行緒執行，又可以有Future的那些操作。它的兩個構造器如下
FutureTask(Callable<V> callable);
FutureTask(Runnable runnable, V result);
複製程式碼簡單應用
FutureTask<String> futureTask = new FutureTask<>(() -> "2333");
Thread T1 = new Thread(futureTask);
T1.start();
String result = futureTask.get();
System.out.println(result);
複製程式碼執行緒池應用
一般情況我們在用多執行緒的時候都會上執行緒池，而且一般我們使用ThreadPoolExecutor來建立執行緒池，我的上篇文章已經講述了ThreadPoolExecutor，這裡再補充一下submit用法。
Future<?> submit(Runnable task); // 提交 Runnable 任務
<T> Future<T> submit(Callable<T> task); // 提交 Callable 任務
<T> Future<T> submit(Runnable task, T result); // 提交 Runnable 任務及結果引用
複製程式碼也就是說如果我們需要返回任務的執行結果我們就得呼叫submit方法而不是execute。 submit也不神祕就是封裝了一下我們的任務再execute
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null); //轉成 RunnableFuture，傳的result是null
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
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;
}
複製程式碼newTaskFor方法是new了一個FutureTask返回。 所以三個方法其實都是把task轉成FutureTask，如果task是Callable，就直接賦值。如果是Runnable 就轉為Callable再賦值
task是Callable的情況
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;
}
複製程式碼task是Runnable 的情況
// 按順序看，層層呼叫
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result); //轉 runnable 為 callable
this.state = NEW;
}
// 以下為Executors中的方法
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
static final class RunnableAdapter<T> implements Callable<T> { //介面卡
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
複製程式碼看了原始碼就揭開了神祕面紗了，就是因為Future需要返回結果，所以內部task必須是Callable，如果task是Runnable 我就造個假，偷天換日，在Runnable 外面包個Callable馬甲，返回的結果在構造時就寫好。
如果是呼叫Future<?> submit(Runnable task);提交任務，構造的時候就直接是RunnableFuture<Void> ftask = newTaskFor(task, null);直接塞了個null。所以呼叫Future.get時，拿到的就是null。所以這樣有什麼用呢？就只用能來判斷任務已經執行完畢，就類似於Thread.join。
這還有個<T> Future<T> submit(Runnable task, T result);你可能會奇怪這有啥用啊，你傳入一個result，Future.get的時候返回的不還是這個result嘛。是個沒錯，但是這樣用就行了！
class Task implements Runnable{ //定義task,傳入p
Person p;
Task(Person r){ // 通過建構函式傳入 p
this.p = p;
}
void run() {
r.setSex("男"); // 可以修改p
}
}
Person p = new Person();
p.setName("小明")；
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<Result> future = executor.submit(new Task(p), p);
Person person = future.get();
person.getSex();
複製程式碼這樣就可以得到修改後的結果了！
總結
綜上所述，知道了Runnable 和Callable 的區別，Callable 可以獲得任務結果和丟擲異常，Runnable 沒結果沒異常丟擲。
Future可以很容易的獲得非同步執行的結果，並且對任務進行一些操控。並且get等待結果時會阻塞，所以當任務之間有依賴關係的時候，一個任務依賴另一個任務的結果，可以用Future的get來等待依賴的任務完成的結果。
FutureTask 就是具體的實現類，有Runnable 的特性又有Future的特性，內部包的是Callable ，當然也有接受Runnable 的構造器，只是會偷偷把Runnable 轉成Callable 來實現能返回結果的方法。
如果錯誤歡迎指正！ 個人公眾號：yes的練級攻略