java 多线程 33: 多线程组件之 Callable、Future和FutureTask

2019年3月9日 179次阅读 来源: java 线程池

Callable

Callable和rRunnable差不多，两者都是为那些其实例可能被另一个线程执行的类而设计的，最主要的差别在于Runnable不会返回线程运算结果，Callable可以（假如线程需要返回运行结果）

Future

Future是一个接口表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。Future提供了get()、cancel()、isCancel()、isDone()四种方法，表示Future有三种功能：

1、判断任务是否完成

2、中断任务

3、获取任务执行结果

FutureTask

FutureTask是Future的实现类，也可以说是进阶类，优化了Future的一些缺点，比如Future.get会阻塞等等，它提供了对Future的基本实现。可使用FutureTask包装Callable或Runnable对象，因为FutureTask实现了Runnable和Future（看源码可以看出来），所以也可以将FutureTask提交给Executor。一般使用FutureTask代替Future即可

使用方法

Callable、Future、FutureTask一般都是和线程池配合使用的，因为线程池ThreadPoolExecutor的父类AbstractExecutorService提供了三种submit方法：

1、public Future<?> subit(Runnable task){…}

2、public <T> Future<T> submit<Runnable task, T result>{…}

3、public <T> Future<T> submit<Callable<T> task>{…}

第2个用得不多，第1个和第3个比较有用

Callable+Future使用示例

public static class CallableThread implements Callable<String>
{
    public String call() throws Exception
    {
        System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis());
        Thread.sleep(10000);
        return "123";
    }
}
    
public static void main(String[] args) throws Exception
{
    ExecutorService es = Executors.newCachedThreadPool();
    CallableThread ct = new CallableThread();
    Future<String> f = es.submit(ct);
    es.shutdown();
        
    Thread.sleep(5000);
    System.out.println("主线程等待5秒, 当前时间为" + System.currentTimeMillis());
        
    String str = f.get();
    System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis());
}

运行结果为：

进入CallableThread的call()方法, 开始睡觉, 睡觉时间为1444654421368
主线程等待5秒, 当前时间为1444654426369
Future已拿到数据, str = 123, 当前时间为1444654431369

看到任意一个利用Callable接口submit上去的任务，只要有一个Future接受它，Future便可以在程序任何地点尝试去获取这条线程返回出去的数据，时间可以比对一下，正好10000ms，即10s

这里的 Future.get 是阻塞方法 ， 会一直等待Callable中线程任务执行完毕，是很低下的效率，

解决方式

1.可以使用FutureTask ，重写done方法

2.循环判断isDone，返回true的时候然后调用get()获取


Callable+FutureTask使用示例

有兴趣的可以看下源码，其实使用Callable+Future的方式，es.submit(ct)方法返回的Future，底层实现new出来的是一个FutureTask。那么，我们看一下Callable+FutureTask的方式：


  
 
    
   
  
  1. public static class CallableThread implements Callable<String>
    2. 
   
  
  2.  {
    3. 
   
  
  3.  public String call() throws Exception
    4. 
   
  
  4.  {
    5. 
   
  
  5.  System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis());
    6. 
   
  
  6.  Thread.sleep(10000);
    7. 
   
  
  7.  System.out.println("线程睡眠 10s完毕 返回 123");
    8. 
   
  
  8.  return "123";
    9. 
   
  
  9.  }
    10. 
   
  
  10.  }
    11. 
   
  
    12. 
   
  
    13. 
   
  
  13.  public static class MyFutureTask<String> extends FutureTask<String>{
    14. 
   
  
    15. 
   
  
  15.  public MyFutureTask(Callable callable) {
    16. 
   
  
  16.  super(callable);
    17. 
   
  
  17.  }
    18. 
   
  
    19. 
   
  
  19.  @Override
    20. 
   
  
  20.  protected void done() {
    21. 
   
  
  21.  super.done();
    22. 
   
  
  22.  try {
    23. 
   
  
  23.  String str = this.get();
    24. 
   
  
  24.  System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis());
    25. 
   
  
  25.  } catch (InterruptedException e) {
    26. 
   
  
  26.  e.printStackTrace();
    27. 
   
  
  27.  } catch (ExecutionException e) {
    28. 
   
  
  28.  e.printStackTrace();
    29. 
   
  
  29.  }
    30. 
   
  
    31. 
   
  
  31.  }
    32. 
   
  
  32.  }
    33. 
   
  
  33.  public static void main(String[] args) throws InterruptedException, ExecutionException {
    34. 
   
  
  34.  ExecutorService es = Executors.newCachedThreadPool();
    35. 
   
  
  35.  CallableThread ct = new CallableThread();
    36. 
   
  
  36.  MyFutureTask<String> f = new MyFutureTask<>(ct);
    37. 
   
  
  37.  es.submit(f);
    38. 
   
  
  38.  es.shutdown();
    39. 
   
  
    40. 
   
  
  40.  System.out.println("主线程执行完毕, 当前时间为" + System.currentTimeMillis());
    41. 
   
  
    42. 
   
  
    43. 
   
  
  43.  }
    44.

执行结果

  
 
    
   
  
  1. 主线程执行完毕, 当前时间为1474276672135
    2. 
   
  
  2. 进入CallableThread的call()方法, 开始睡觉, 睡觉时间为1474276672135
    3. 
   
  
  3. 线程睡眠 10s完毕 返回 123
    4. 
   
  
  4. Future已拿到数据, str = 123, 当前时间为1474276682135
    5.


可以看到通过FutureTask 构造传入 Callable 类， 重写 done 处理线程执行完毕之后的代码，和Future不同的是，FutureTask集成了Callable ，只需要传入一个Callable， 就可以在内部实现Callable完成后的处理，也不会占用main线程了




使用Callable、Future和FutureTask的好处

上面演示了两个例子，其实反映的是现实中一种情况，把上面的例子稍微扩展一下就是：

有一个method()方法，方法中执行方法A返回一个数据要10秒钟，A方法后面的代码一共要执行20秒钟，但是这20秒的代码中有10秒的方法并不依赖方法A的执行结果，有10秒钟的代码依赖方法A的执行结果。此时若采用同步的方式，那么势必要先等待10秒钟，等待方法A执行完毕，返回数据，再执行后面20秒的代码。

不得不说这是一种低效率的做法。有了Callable、Future和FutureTask，那么：

1、先把A方法的内容放到Callable实现类的call()方法中

2、method()方法中，Callable实现类传入Executor的submit方法中

3、执行后面方法中10秒不依赖方法A运行结果的代码

4、获取方法A的运行结果，执行后面方法中10秒依赖方法A运行结果的代码

这样代码执行效率一下子就提高了，程序不必卡在A方法处。

当然，也可以不用Callable，采用实现Runnable的方式，run()方法执行完了想个办法给method()方法中的某个变量V赋个值就好了。但是我上一篇文章开头就说了，之所以要用多线程组件，就是因为JDK帮我们很好地实现好了代码细节，让开发者更多可以关注业务层的逻辑。如果使用Runnable的方式，那么我们自己就要考虑很多细节，比如Runnable实现类的run()方法执行完毕给V赋值是否线程安全、10秒后如果A方法没有执行完导致V还没有值怎么办，何况JDK还给用户提供了取消任务、判断任务是否存在等方法。既然JDK已经帮我们考虑并实现这些细节了，在没有有说服力的理由的情况下，我们为什么还要自己写run()方法的实现呢？ 

    原文作者：java 线程池
    原文地址: http://www.cnblogs.com/signheart/p/cc20668bc6916f2664bd3e09cddc46d1.html
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞