码迷，mamicode.com
首页 > 其他好文 > 详细

Runnable、Callable、Executor、Future、FutureTask关系解读

时间：2017-10-28 11:23:42      阅读：174      评论：0      收藏：0      [点我收藏+]

标签：tostring   oop   返回结果   cal   auto   主线程   running   检查   out   

在再度温习Java5的并发编程的知识点时发现，首要的就是把Runnable、Callable、Executor、Future等的关系搞明白，遂有了下述小测试程序，通过这个例子上述三者的关系就一目了然了。

在java5以后，一个可以调度执行的线程单元可以有三种方式定义：

Thread、Runnable、Callable，其中Runnable实现的是void run()方法，Callable实现的是 V call()方法，并且可以返回执行结果，其中Runnable可以提交给Thread来包装下，直接启动一个线程来执行，而Callable则一般都是提交给ExecuteService来执行。

简单来说，Executor就是Runnable和Callable的调度容器，Future就是对于具体的调度任务的执行结果进行查看，最为关键的是Future可以检查对应的任务是否已经完成，也可以阻塞在get方法上一直等待任务返回结果。Runnable和Callable的差别就是Runnable是没有结果可以返回的，就算是通过Future也看不到任务调度的结果的。 

[java] view plain copy
  1. /** 
  2.  * 通过简单的测试程序来试验Runnable、Callable通过Executor来调度的时候与Future的关系 
  3.  */  
  4. package com.hadoop.thread;  
  5.   
  6. import java.util.concurrent.Callable;  
  7. import java.util.concurrent.ExecutorService;  
  8. import java.util.concurrent.Executors;  
  9. import java.util.concurrent.Future;  
  10.   
  11. public class RunnableAndCallable2Future {  
  12.   
  13.     public static void main(String[] args) {  
  14.   
  15.         // 创建一个执行任务的服务  
  16.         ExecutorService executor = Executors.newFixedThreadPool(3);  
  17.         try {  
  18.             //1.Runnable通过Future返回结果为空  
  19.             //创建一个Runnable，来调度，等待任务执行完毕，取得返回结果  
  20.             Future<?> runnable1 = executor.submit(new Runnable() {  
  21.                 @Override  
  22.                 public void run() {  
  23.                     System.out.println("runnable1 running.");  
  24.                 }  
  25.             });  
  26.             System.out.println("Runnable1:" + runnable1.get());  
  27.   
  28.             // 2.Callable通过Future能返回结果  
  29.             //提交并执行任务，任务启动时返回了一个 Future对象，  
  30.             // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作  
  31.             Future<String> future1 = executor.submit(new Callable<String>() {  
  32.                 @Override  
  33.                 public String call() throws Exception {  
  34.                     // TODO Auto-generated method stub  
  35.                     return "result=task1";  
  36.                 }  
  37.             });  
  38.             // 获得任务的结果，如果调用get方法，当前线程会等待任务执行完毕后才往下执行  
  39.             System.out.println("task1: " + future1.get());  
  40.   
  41.             //3. 对Callable调用cancel可以对对该任务进行中断  
  42.             //提交并执行任务，任务启动时返回了一个 Future对象，  
  43.             // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作  
  44.             Future<String> future2 = executor.submit(new Callable<String>() {  
  45.                 @Override  
  46.                 public String call() throws Exception {               
  47.                     try {  
  48.                         while (true) {  
  49.                             System.out.println("task2 running.");  
  50.                             Thread.sleep(50);  
  51.                         }  
  52.                     } catch (InterruptedException e) {  
  53.                         System.out.println("Interrupted task2.");  
  54.                     }  
  55.                     return "task2=false";  
  56.                 }  
  57.             });  
  58.               
  59.             // 等待5秒后，再停止第二个任务。因为第二个任务进行的是无限循环  
  60.             Thread.sleep(10);  
  61.             System.out.println("task2 cancel: " + future2.cancel(true));  
  62.   
  63.             // 4.用Callable时抛出异常则Future什么也取不到了  
  64.             // 获取第三个任务的输出，因为执行第三个任务会引起异常  
  65.             // 所以下面的语句将引起异常的抛出  
  66.             Future<String> future3 = executor.submit(new Callable<String>() {  
  67.   
  68.                 @Override  
  69.                 public String call() throws Exception {  
  70.                     throw new Exception("task3 throw exception!");  
  71.                 }  
  72.   
  73.             });  
  74.             System.out.println("task3: " + future3.get());  
  75.         } catch (Exception e) {  
  76.             System.out.println(e.toString());  
  77.         }  
  78.         // 停止任务执行服务  
  79.         executor.shutdownNow();  
  80.     }  
  81. }  

执行结果如下：

[plain] view plain copy
  1. runnable1 running.  
  2. Runnable1:null  
  3. task1: result=task1  
  4. task2 running.  
  5. task2 cancel: true  
  6. Interrupted task2.  
  7. java.util.concurrent.ExecutionException: java.lang.Exception: Bad flag value!  

FutureTask则是一个RunnableFuture<V>，即实现了Runnbale又实现了Futrue<V>这两个接口，另外它还可以包装Runnable和Callable<V>，所以一般来讲是一个符合体了，它可以通过Thread包装来直接执行，也可以提交给ExecuteService来执行，并且还可以通过v get()返回执行结果，在线程体没有执行完成的时候，主线程一直阻塞等待，执行完则直接返回结果。

 

[java] view plain copy
  1. public class FutureTaskTest {  
  2.   
  3.     /** 
  4.      * @param args 
  5.      */  
  6.     public static void main(String[] args) {  
  7.         Callable<String> task = new Callable<String>() {  
  8.             public String call() {  
  9.                 System.out.println("Sleep start.");  
  10.                 try {  
  11.                     Thread.sleep(1000 * 10);  
  12.                 } catch (InterruptedException e) {  
  13.                     // TODO Auto-generated catch block  
  14.                     e.printStackTrace();  
  15.                 }  
  16.                 System.out.println("Sleep end.");  
  17.                 return "time=" + System.currentTimeMillis();  
  18.             }  
  19.         };  
  20.           
  21.         //直接使用Thread的方式执行  
  22.         FutureTask<String> ft = new FutureTask<String>(task);  
  23.         Thread t = new Thread(ft);  
  24.         t.start();  
  25.         try {  
  26.             System.out.println("waiting execute result");  
  27.             System.out.println("result = " + ft.get());  
  28.         } catch (InterruptedException e) {  
  29.             // TODO Auto-generated catch block  
  30.             e.printStackTrace();  
  31.         } catch (ExecutionException e) {  
  32.             // TODO Auto-generated catch block  
  33.             e.printStackTrace();  
  34.         }  
  35.           
  36.         //使用Executors来执行  
  37.         System.out.println("=========");  
  38.         FutureTask<String> ft2 = new FutureTask<String>(task);  
  39.         Executors.newSingleThreadExecutor().submit(ft2);  
  40.         try {  
  41.             System.out.println("waiting execute result");  
  42.             System.out.println("result = " + ft2.get());  
  43.         } catch (InterruptedException e) {  
  44.             // TODO Auto-generated catch block  
  45.             e.printStackTrace();  
  46.         } catch (ExecutionException e) {  
  47.             // TODO Auto-generated catch block  
  48.             e.printStackTrace();  
  49.         }  
  50.           
  51.     }  
  52. }  


执行结果如下：

 

 

 

[java] view plain copy
    1. waiting execute result  
    2. Sleep start.  
    3. Sleep end.  
    4. result = time=1370844662537  
    5. =========  
    6. waiting execute result  
    7. Sleep start.  
    8. Sleep end.  
    9. result = time=1370844672542  

Runnable、Callable、Executor、Future、FutureTask关系解读

标签：tostring   oop   返回结果   cal   auto   主线程   running   检查   out   

原文地址：http://www.cnblogs.com/cristin/p/7746018.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！