FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。
1. FutureTask执行多任务计算的使用场景
利用FutureTask和ExecutorService，可以用多线程的方式提交计算任务，主线程继续执行其他任务，当主线程需要子线程的计算结果时，在异步获取子线程的执行结果。
1. package futuretask;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5. import java.util.concurrent.Callable;
6. import java.util.concurrent.ExecutionException;
7. import java.util.concurrent.ExecutorService;
8. import java.util.concurrent.Executors;
9. import java.util.concurrent.FutureTask;
10.
11. public class FutureTaskForMultiCompute {
12.
13. public static void main(String[] args) {
14.
15. new FutureTaskForMultiCompute();
16. // 创建任务集合
17. new ArrayList>();
18. // 创建线程池
19. 5);
20. for (int i = 0; i (inst.new ComputeTask(i, ""+i));
23. taskList.add(ft);
24. // 提交给线程池执行任务，也可以通过exec.invokeAll(taskList)一次性提交所有任务;
25. exec.submit(ft);
26. }
27.
28. "所有计算任务提交完毕, 主线程接着干其他事情！");
29.
30. // 开始统计各计算线程计算结果
31. 0;
32. for (FutureTask ft : taskList) {
33. try {
34. //FutureTask的get方法会自动阻塞,直到获取计算结果为止
35. totalResult = totalResult + ft.get();
36. catch (InterruptedException e) {
37. e.printStackTrace();
38. catch (ExecutionException e) {
39. e.printStackTrace();
40. }
41. }
42.
43. // 关闭线程池
44. exec.shutdown();
45. "多任务计算后的总结果是:" + totalResult);
46.
47. }
48.
49. private class ComputeTask implements Callable {
50.
51. private Integer result = 0;
52. private String taskName = "";
53.
54. public ComputeTask(Integer iniResult, String taskName){
55. result = iniResult;
56. this.taskName = taskName;
57. "生成子线程计算任务: "+taskName);
58. }
59.
60. public String getTaskName(){
61. return this.taskName;
62. }
63.
64. @Override
65. public Integer call() throws Exception {
66. // TODO Auto-generated method stub
67.
68. for (int i = 0; i
2. FutureTask在高并发环境下确保任务只执行一次
在很多高并发的环境下，往往我们只需要某些任务只执行一次。这种使用情景FutureTask的特性恰能胜任。举一个例子，假设有一个带key的连接池，当key存在时，即直接返回key对应的对象；当key不存在时，则创建连接。对于这样的应用场景，通常采用的方法为使用一个Map对象来存储key和连接池对应的对应关系，典型的代码如下面所示：
1. private Map connectionPool = new HashMap();
2. private ReentrantLock lock = new ReentrantLock();
3.
4. public Connection getConnection(String key){
5. try{
6. lock.lock();
7. if(connectionPool.containsKey(key)){
8. return connectionPool.get(key);
9. }
10. else{
11. //创建 Connection
12. Connection conn = createConnection();
13. connectionPool.put(key, conn);
14. return conn;
15. }
16. }
17. finally{
18. lock.unlock();
19. }
20. }
21.
22. //创建Connection
23. private Connection createConnection(){
24. return null;
25. } 在上面的例子中，我们通过加锁确保高并发环境下的线程安全，也确保了connection只创建一次，然而确牺牲了性能。改用ConcurrentHash的情况下，几乎可以避免加锁的操作，性能大大提高，但是在高并发的情况下有可能出现Connection被创建多次的现象。这时最需要解决的问题就是当key不存在时，创建Connection的动作能放在connectionPool之后执行，这正是FutureTask发挥作用的时机，基于ConcurrentHashMap和FutureTask的改造代码如下：
1. private ConcurrentHashMap>connectionPool = new ConcurrentHashMap>();
2.
3. public Connection getConnection(String key) throws Exception{
4. FutureTaskconnectionTask=connectionPool.get(key);
5. if(connectionTask!=null){
6. return connectionTask.get();
7. }
8. else{
9. new Callable(){
10. @Override
11. public Connection call() throws Exception {
12. // TODO Auto-generated method stub
13. return createConnection();
14. }
15. };
16. new FutureTask(callable);
17. connectionTask = connectionPool.putIfAbsent(key, newTask);
18. if(connectionTask==null){
19. connectionTask = newTask;
20. connectionTask.run();
21. }
22. return connectionTask.get();
23. }
24. }
25.
26. //创建Connection
27. private Connection createConnection(){
28. return null;
29. } 经过这样的改造，可以避免由于并发带来的多次创建连接及锁的出现。
服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
机房租用，北京机房租用，IDC机房托管， http://www.e1idc.net
