[转]FutureTask详解

 FutureTask类是Future 的一个实现，并实现了Runnable，所以可通过Excutor(线程池) 来执行,也可传递给Thread对象执行。如果在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给Future对象在后台完成，当主线程将来需要时，就可以通过Future对象获得后台作业的计算结果或者执行状态。  

Executor框架利用FutureTask来完成异步任务，并可以用来进行任何潜在的耗时的计算。一般FutureTask多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。

FutureTask是一种可以取消的异步的计算任务。它的计算是通过Callable实现的，它等价于可以携带结果的Runnable，并且有三个状态：等待、运行和完成。完成包括所有计算以任意的方式结束，包括正常结束、取消和异常。 

Future有个get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。

FutureTask有下面几个重要的方法：

1.get()

阻塞一直等待执行完成拿到结果

 2.get(int timeout, TimeUnit timeUnit)

阻塞一直等待执行完成拿到结果，如果在超时时间内，没有拿到抛出异常 

3.isCancelled()

是否被取消

4.isDone()

是否已经完成

5.cancel(boolean mayInterruptIfRunning)

试图取消正在执行的任务

demo1:

package net.jcip.examples;  
  
import java.util.Random;    
import java.util.concurrent.Callable;    
import java.util.concurrent.ExecutionException;    
import java.util.concurrent.FutureTask;    
    
/**  
 *  
 * @author Administrator  
 *  
 */    
@SuppressWarnings("all")    
public class FutureTaskDemo {    
    public static void main(String[] args) {    
        // 初始化一个Callable对象和FutureTask对象    
        Callable pAccount = new PrivateAccount();    
        FutureTask futureTask = new FutureTask(pAccount);    
        // 使用futureTask创建一个线程    
        Thread pAccountThread = new Thread(futureTask);    
        System.out.println("futureTask线程现在开始启动，启动时间为：" + System.nanoTime());    
        pAccountThread.start();    
        System.out.println("主线程开始执行其他任务");    
        // 从其他账户获取总金额    
        int totalMoney = new Random().nextInt(100000);    
        System.out.println("现在你在其他账户中的总金额为" + totalMoney);    
        System.out.println("等待私有账户总金额统计完毕...");    
        // 测试后台的计算线程是否完成，如果未完成则等待    
        while (!futureTask.isDone()) {    
            try {    
                Thread.sleep(500);    
                System.out.println("私有账户计算未完成继续等待...");    
            } catch (InterruptedException e) {    
                e.printStackTrace();    
            }    
        }    
        System.out.println("futureTask线程计算完毕，此时时间为" + System.nanoTime());    
        Integer privateAccountMoney = null;    
        try {    
            privateAccountMoney = (Integer) futureTask.get();    
        } catch (InterruptedException e) {    
            e.printStackTrace();    
        } catch (ExecutionException e) {    
            e.printStackTrace();    
        }    
        System.out.println("您现在的总金额为：" + totalMoney + privateAccountMoney.intValue());    
    }    
}    
    
@SuppressWarnings("all")    
class PrivateAccount implements Callable {    
    Integer totalMoney;    
    
    @Override    
    public Object call() throws Exception {    
        Thread.sleep(5000);    
        totalMoney = new Integer(new Random().nextInt(10000));    
        System.out.println("您当前有" + totalMoney + "在您的私有账户中");    
        return totalMoney;    
    }    
    
}  

demo2:

package net.jcip.examples;  
  
import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.FutureTask;  
  
public class FutureTaskSample {    
      
    static FutureTask<String> future = new FutureTask(new Callable<String>(){    
        public String call(){    
            return getPageContent();    
        }    
    });    
        
    public static void main(String[] args) throws InterruptedException, ExecutionException{    
        //Start a thread to let this thread to do the time exhausting thing    
        new Thread(future).start();    
    
        //Main thread can do own required thing first    
       System.out.println(doOwnThing());    
    
        //At the needed time, main thread can get the result    
//       while(future.isDone())  
       for(;;){  
           if(future.isDone()){  
               System.out.println(future.get());   
           break;  
           }else  
               System.out.println("waiting………………");  
       }  
    }    
        
    public static String doOwnThing(){    
        return "Do Own Thing";    
    }    
    public static String getPageContent(){   
        try {  
            Thread.sleep(1000);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        return "testPageContent and provide that the operation is a time exhausted thing...";    
    }    
}  

(原文地址:http://blog.csdn.net/bbgb1984/article/details/8471873)