搞懂Runnable Callable Future FutureTask 及應用

通常建立線程只有兩種方式，一種是繼承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的練級攻略