1、Future
線程是異步的，所以不可能直接從別的線程中得到函數返回值。Futrue可以監視目標線程調用call的情況，當調用Future的get()方法獲得結果時，當前線程就開始阻塞，直接call方法結束返回結果
任務提交給Future，由Future控制Executor來完成這個任務。一段時間后，可以從Future那兒取出結果。
Future接口是Future<V>，其中V代表了Future執行的任務返回值的類型。

Future接口的方法介紹：
boolean cancel (boolean mayInterruptIfRunning)
取消任務的執行。參數指定是否立即中斷任務，或者等待一會結束
boolean isCancelled ()
任務是否已經取消，任務正常完成前將其取消，則返回true
boolean isDone ()
任務是否已經完成。如果任務正常終止、異常或取消，都將返回true
V get () throws InterruptedException, ExecutionException
等待任務執行結束，然后獲得V類型的結果。InterruptedException線程被中斷的異常，ExecutionException任務執行的異常，如果任務被取消，還會拋出CancellationException
V get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException
同上面的get功能一樣，多了設置超時時間。超時，將拋出TimeoutException

下面是一個使用Future計算Fibonacci數列的demo
通過future.get()取得Callable的返回結果，用于后面的計算

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Future20170322 {
    static int f0 = 1;
    static int f1 = 1;
    static int f2 = 0;
    
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();

        for(int i=2; i<10; i++) {
            Future<Integer> future = threadPool.submit(new Callable<Integer>() {
                public Integer call() throws Exception {
                    return f0 + f1;
                }
            });
            try {
                f2 = future.get();
                f0 = f1;
                f1 = f2;
                System.out.println(f2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

2、FutureTask
為什么要使用FutureTask？
Future可以通過Future.get()來取得計算結果。但是，若開啟了多個任務，就不知道哪個任務最先結束。因此，若要實現 “當某任務結束時，立刻做某些事情”這一功能，就需要寫一些額外的代碼

package FutureTask20170329;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTask20170329 { 
    
    public static void main(String[] args) {  
        ExecutorService executor = Executors.newCachedThreadPool();  
        //循環創建5個任務，并把他放到FutureTask中
        for(int i=0; i<5; i++) {
            Callable<String> c = new Task();  
            MyFutureTask ft = new MyFutureTask(c);  
            executor.submit(ft);  
        }  
        executor.shutdown();  
    }  
          
}  
  
class MyFutureTask extends FutureTask<String> {  
  
    public MyFutureTask(Callable<String> callable) {  
        super(callable);  
    }  
  
    //回調函數，當任務完成時就會被出發
    @Override  
    protected void done() {  
        try {  
            System.out.println(get() + " 線程執行完畢！");  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (ExecutionException  e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
    }  
      
      
}  
  
//創建一個任務，隨機睡眠10s之內
class Task implements Callable<String> {  
  
    public String call() throws Exception {  
        Random rand = new Random();  
        Thread.sleep(rand.nextInt(10));  
        return Thread.currentThread().getName();  
    }  
} 

執行結果：

Paste_Image.png

從結果可以看出，每個線程執行完畢都會知道，所以可以在其中加入任務完畢之后所需的操作。
使用遍歷的方式雖然也可以解決取得多任務結果的問題，但卻不是最優的效果，FutureTask正是為此而存在，它有一個回調函數protected void done()，當任務結束時，該回調函數會被觸發。因此，只需重載該函數，即可實現在線程剛結束時就做某些事情