java FutureTask-阿里云开发者社区

java FutureTask

2016-03-03 1220

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： public class FutureTask<V> extends Object implements Future<V>, Runnable 可见FutureTask 是继承 Future ，产看future源码得到 public interface Future<V> Future ，在Future

public class FutureTask<V> extends Object
implements Future<V>, Runnable

可见FutureTask 是继承 Future ，产看future源码得到 public interface Future<V> Future ，在Future中有个get方法而获取结果只有在计算完成时，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。

Future中主要定义了5个方法：

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

2）boolean isCancelled()：如果在任务正常完成前将其取消，则返回 true。
3）boolean isDone()：如果任务已完成，则返回 true。可能由于正常终止、异常或取消而完成，在所有这些情况中，此方法都将返回 true。
4）V get()throws InterruptedException,ExecutionException：如有必要，等待计算完成，然后获取其结果。
5）V get(long timeout,TimeUnit unit) throws InterruptedException,ExecutionException,TimeoutException：如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。

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

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

JDK提供了对Future的基本实现，仅在计算完成后才能检索结果，如果未完成，则阻塞get（）方法，一旦计算完成，就不能重新开始或者取消。

可使用FuttreTask 包装Callable或者Runnable对象。因为FutureTask实现Runnble，所以可将FutureTask提交给Executor执行。

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

下面的例子模拟一个会计算账的过程，主线程已经获得其他帐户的总额了，为了不让主线程等待 PrivateAccount类的计算结果的返回而启用新的线程去处理，并使用 FutureTask对象来监控，这样，主线程还可以继续做其他事情，最后需要计算总额的时候再尝试去获得privateAccount 的信息。

     Java代码  
     
   
package test;  
  
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;  
    }  
  
}  

运行结果

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
doOwnThing();
//At the needed time, main thread can get the result
System.out.println(future.get());
}
public static String doOwnThing(){
return "Do Own Thing";
}
public static String getPageContent(){
return "testPageContent and provide that the operation is a time exhausted thing...";
}
}

   下面是
  Callable 和 Runnable的介绍： 
 

编写多线程程序是为了实现多任务的并发执行，从而能够更好地与用户交互。一般有三种方法，Thread,Runnable,Callable.
Runnable和Callable的区别是，
 (1)Callable规定的方法是call(),Runnable规定的方法是run().
 (2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
 (3)call方法可以抛出异常，run方法不可以
 (4)运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。
1、通过实现Runnable接口来创建Thread线程：
  步骤1：创建实现Runnable接口的类：
         
 class SomeRunnable implements Runnable
 {
     public void run()
     {
       //do something here
     }
 }

通过线程池来创建线程：

步骤1：创建线程池：

ExecutorService pool = Executors.newCachedThreadPool();

步骤2：通过Runnable对象或Callable对象将任务提交给ExecutorService对象：

Future<Integer> submit(Callable<Integer> task);

注释：Future是一个接口，它的定义如下：

public interface Future<T>
{
    V get() throws ...;
    V get(long timeout, TimeUnit unit) throws ...;
    void cancle(boolean mayInterrupt);
    boolean isCancelled();
    boolean isDone();
}

至此，一个线程就创建完成了。

注释：线程池需调用shutdown();方法来关闭线程。

文章标签：

Java

关键词：

Java FutureTask

java FutureTask

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

java FutureTask

热门文章

最新文章

相关课程

相关电子书

相关实验场景