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...";  
    }  
}