java的FutureTask類

1.FutrueTask概念

FutureTask一個可取消的異步計算，FutureTask 實現了Future的基本方法，提空 start cancel 操作，可以查詢計算是否已經完成，並且可以獲取計算的結果。結果只可以在計算完成之后獲取，get方法會阻塞當計算沒有完成的時候，一旦計算已經完成，那么計算就不能再次啟動或是取消。

一個FutureTask 可以用來包裝一個 Callable 或是一個runnable對象。因為FurtureTask實現了Runnable方法，所以一個 FutureTask可以提交(submit)給一個Excutor執行(excution).

2.FutureTask使用場景

FutureTask可用於異步獲取執行結果或取消執行任務的場景。通過傳入Runnable或者Callable的任務給FutureTask，直接調用其run方法或者放入線程池執行，之后可以在外部通過FutureTask的get方法異步獲取執行結果，因此，FutureTask非常適合用於耗時的計算，主線程可以在完成自己的任務后，再去獲取結果。另外，FutureTask還可以確保即使調用了多次run方法，它都只會執行一次Runnable或者Callable任務，或者通過cancel取消FutureTask的執行等。

2.1 FutureTask執行多任務計算場景

利用FutureTask和ExecutorService，可以用多線程的方式提交計算任務，主線程繼續執行其他任務，當主線程需要子線程的計算結果時，在異步獲取子線程的執行結果。

/**
 * Created by zhumiao on 2018/8/17.
 */
public class FutureTest1 {
    public static void main(String[] args) {
        Task task = new Task();// 新建異步任務
        FutureTask<Integer> future = new FutureTask<Integer>(task) {
            // 異步任務執行完成，回調
            @Override
            protected void done() {
                try {
                    System.out.println("future.done():" + get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        };
        // 創建線程池（使用了預定義的配置）
        ExecutorService executor = Executors.newCachedThreadPool();
        executor.execute(future);

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        // 可以取消異步任務
//         future.cancel(true);
        try {
            // 阻塞，等待異步任務執行完畢-獲取異步任務的返回值
            System.out.println("future.get():" + future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    // 異步任務
    static class Task implements Callable<Integer> {
        // 返回異步任務的執行結果
        @Override
        public Integer call() throws Exception {
            int i = 0;
            for (; i < 10; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + "_"
                            + i);
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return i;
        }
    }
}

2.2 FutureTask在高並發下確保任務只執行一次

在很多高並發的環境下，往往我們只需要某些任務只執行一次。這種使用情景FutureTask的特性恰能勝任。舉一個例子，假設有一個帶key的連接池，當key存在時，即直接返回key對應的對象；當key不存在時，則創建連接。對於這樣的應用場景，通常采用的方法為使用一個Map對象來存儲key和連接池對應的對應關系，典型的代碼如下面所示：

private Map<String, Connection> connectionPool = new HashMap<String, Connection>();  
private ReentrantLock lock = new ReentrantLock();  

public Connection getConnection(String key){  
    try{  
        lock.lock();  
        if(connectionPool.containsKey(key)){  
            return connectionPool.get(key);  
        }  
        else{  
            //創建 Connection  
            Connection conn = createConnection();  
            connectionPool.put(key, conn);  
            return conn;  
        }  
    }  
    finally{  
        lock.unlock();  
    }  
}  

//創建Connection（根據業務需求，自定義Connection）  
private Connection createConnection(){  
    return null;  
} 

在上面的例子中，我們通過加鎖確保高並發環境下的線程安全，也確保了connection只創建一次，然而確犧牲了性能。改用ConcurrentHash的情況下，幾乎可以避免加鎖的操作，性能大大提高，但是在高並發的情況下有可能出現Connection被創建多次的現象。這時最需要解決的問題就是當key不存在時，創建Connection的動作能放在connectionPool之后執行，這正是FutureTask發揮作用的時機，基於ConcurrentHashMap和FutureTask的改造代碼如下：

private ConcurrentHashMap<String,FutureTask<Connection>>connectionPool = new ConcurrentHashMap<String, FutureTask<Connection>>();  

public Connection getConnection(String key) throws Exception{  
    FutureTask<Connection>connectionTask=connectionPool.get(key);  
    if(connectionTask!=null){  
        return connectionTask.get();  
    }  
    else{  
        Callable<Connection> callable = new Callable<Connection>(){  
            @Override  
            public Connection call() throws Exception {  
                // TODO Auto-generated method stub  
                return createConnection();  
            }  
        };  
        FutureTask<Connection>newTask = new FutureTask<Connection>(callable);  
        connectionTask = connectionPool.putIfAbsent(key, newTask);  
        if(connectionTask==null){  
            connectionTask = newTask;  
            connectionTask.run();  
        }  
        return connectionTask.get();  
    }  
}  

//創建Connection（根據業務需求，自定義Connection）  
private Connection createConnection(){  
    return null;  
} 

經過這樣的改造，可以避免由於並發帶來的多次創建連接及鎖的出現。