FutureTask

参考 ：Runnable、Callable、Executor、Future、FutureTask关系解读

Future和FutureTask

一个很好的例子 ，

 

/** 
 * 通过简单的测试程序来试验Runnable、Callable通过Executor来调度的时候与Future的关系 
 */  
package com.hadoop.thread;  
  
import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Future;  
  
public class RunnableAndCallable2Future {  
  
    public static void main(String[] args) {  
  
        // 创建一个执行任务的服务  
        ExecutorService executor = Executors.newFixedThreadPool(3);  
        try {  
            //1.Runnable通过Future返回结果为空  
            //创建一个Runnable，来调度，等待任务执行完毕，取得返回结果  
            Future<?> runnable1 = executor.submit(new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println("runnable1 running.");  
                }  
            });  
            System.out.println("Runnable1:" + runnable1.get());  
  
            // 2.Callable通过Future能返回结果  
            //提交并执行任务，任务启动时返回了一个 Future对象，  
            // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作  
            Future<String> future1 = executor.submit(new Callable<String>() {  
                @Override  
                public String call() throws Exception {  
                    // TODO Auto-generated method stub  
                    return "result=task1";  
                }  
            });  
            // 获得任务的结果，如果调用get方法，当前线程会等待任务执行完毕后才往下执行  
            System.out.println("task1: " + future1.get());  
  
            //3. 对Callable调用cancel可以对对该任务进行中断  
            //提交并执行任务，任务启动时返回了一个 Future对象，  
            // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作  
            Future<String> future2 = executor.submit(new Callable<String>() {  
                @Override  
                public String call() throws Exception {               
                    try {  
                        while (true) {  
                            System.out.println("task2 running.");  
                            Thread.sleep(50);  
                        }  
                    } catch (InterruptedException e) {  
                        System.out.println("Interrupted task2.");  
                    }  
                    return "task2=false";  
                }  
            });  
              
            // 等待5秒后，再停止第二个任务。因为第二个任务进行的是无限循环  
            Thread.sleep(10);  
            System.out.println("task2 cancel: " + future2.cancel(true));  
  
            // 4.用Callable时抛出异常则Future什么也取不到了  
            // 获取第三个任务的输出，因为执行第三个任务会引起异常  
            // 所以下面的语句将引起异常的抛出  
            Future<String> future3 = executor.submit(new Callable<String>() {  
  
                @Override  
                public String call() throws Exception {  
                    throw new Exception("task3 throw exception!");  
                }  
  
            });  
            System.out.println("task3: " + future3.get());  
        } catch (Exception e) {  
            System.out.println(e.toString());  
        }  
        // 停止任务执行服务  
        executor.shutdownNow();  
    }  
}  

 

 

1. 干什么的？

  - 异步计算；主线程可以完成自己的任务后再去获取结果。

  - 类似于Runnable , 但是他是带返回值的！如果在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给Future对象在后台完成，当主线程将来需要时，就可以通过Future对象获得后台作业的计算结果或者执行状态。 

  - FutureTask是为了弥补Thread的不足而设计的，它可以让程序员准确地知道线程什么时候执行完成并获得到线程执行完成后返回的结果（如果有需要）。

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

 

2. FutureTask  与 Runnable  , Callable ,Future 的关系 及区别：

  - Runnable ： 无法获得返回值

  - Callable :： 无法在新线程中(new Thread(Runnable r))使用，只能使用ExecutorService，Thread类只支持Runnable

 - Future :  一个接口，FutureTask 是实现了他

 - FutureTask : 实现了Runnable和Future，所以兼顾两者优点,既可以使用ExecutorService，也可以使用Thread

 

3.构造方法

 

 

FutureTask(Callable<V> callable)   
          创建一个 FutureTask，一旦运行就执行给定的 Callable。  
  
FutureTask(Runnable runnable, V result)   
          创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。  
参数：  
runnable - 可运行的任务。  
result - 成功完成时要返回的结果。  
如果不需要特定的结果，则考虑使用下列形式的构造：Future<?> f = new FutureTask<Object>(runnable, null)  

4. API

  

boolean isDone()：如果任务已完成，则返回 true。 可能由于正常终止、异常或取消而完成，在所有这些情况中，此方法都将返回 true。 
V get()throws InterruptedException,ExecutionException：如有必要，等待计算完成，然后获取其结果。就像在开头的例子看到的一样，如果在主线中调用get(),主线程会一直阻塞直到计算完成 
V get(long timeout,TimeUnit unit) throws InterruptedException,ExecutionException,TimeoutException：如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。

  

cancel(boolean ) // 试图取消对此任务的执行。如果任务已完成、或已取消，或者由于某些其他原因而无法取消，则此尝试将失败。当调用 cancel 时，如果调用成功，而此任务尚未启动，则此任务将永不运行。如果任务已经启动，则 mayInterruptIfRunning 参数确定是否应该以试图停止任务的方式来中断执行此任务的线程。此方法返回后，对 isDone() 的后续调用将始终返回 true。如果此方法返回 true，则对 isCancelled() 的后续调用将始终返回 true。 
isCalcel()

 

 

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("等待私有账户总金额统计完毕...");  
        
        // 测试后台的计算线程是否完成，如果未完成则等待  因为call方法里面sleep(5000)
        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;  
    }  
  
}