FutureTask的用法及兩種常用的使用場景

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

1. FutureTask執行多任務計算的使用場景

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

package futuretask;  
  
import java.util.ArrayList;  
import java.util.List;  
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 FutureTaskForMultiCompute {  
      
    public static void main(String[] args) {  
          
        FutureTaskForMultiCompute inst=new FutureTaskForMultiCompute();  
        // 創建任務集合  
        List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>();  
        // 創建線程池  
        ExecutorService exec = Executors.newFixedThreadPool(5);  
        for (int i = 0; i < 10; i++) {  
            // 傳入Callable對象創建FutureTask對象  
            FutureTask<Integer> ft = new FutureTask<Integer>(inst.new ComputeTask(i, ""+i));  
            taskList.add(ft);  
            // 提交給線程池執行任務，也可以通過exec.invokeAll(taskList)一次性提交所有任務;  
            exec.submit(ft);  
        }  
          
        System.out.println("所有計算任務提交完畢, 主線程接着干其他事情！");  
  
        // 開始統計各計算線程計算結果  
        Integer totalResult = 0;  
        for (FutureTask<Integer> ft : taskList) {  
            try {  
                //FutureTask的get方法會自動阻塞,直到獲取計算結果為止  
                totalResult = totalResult + ft.get();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } catch (ExecutionException e) {  
                e.printStackTrace();  
            }  
        }  
  
        // 關閉線程池  
        exec.shutdown();  
        System.out.println("多任務計算后的總結果是:" + totalResult);  
  
    }  
  
    private class ComputeTask implements Callable<Integer> {  
  
        private Integer result = 0;  
        private String taskName = "";  
          
        public ComputeTask(Integer iniResult, String taskName){  
            result = iniResult;  
            this.taskName = taskName;  
            System.out.println("生成子線程計算任務: "+taskName);  
        }  
          
        public String getTaskName(){  
            return this.taskName;  
        }  
          
        @Override  
        public Integer call() throws Exception {  
            // TODO Auto-generated method stub  
  
            for (int i = 0; i < 100; i++) {  
                result =+ i;  
            }  
            // 休眠5秒鍾，觀察主線程行為，預期的結果是主線程會繼續執行，到要取得FutureTask的結果是等待直至完成。  
            Thread.sleep(5000);  
            System.out.println("子線程計算任務: "+taskName+" 執行完成!");  
            return result;  
        }  
    }  
}  

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  
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  
private Connection createConnection(){  
    return null;  
}