（8）java5线程 Callable与Future的应用

Callable和Future

    Callable接口定义了一个call方法可以作为线程的执行体，但call方法比run方法更强大：

    A、call方法可以有返回值
    B、call方法可以申明抛出异常
 
    Callable接口是JDK5后新增的接口，而且不是Runnable的子接口，所以Callable对象不能直接作为Thread的target。而且call方法还有一个返回值，
    call方法不能直接调用，它作为线程的执行体被调用。那么如何接收call方法的返回值？
    JDK1.5提供了Future接口来代表Callable接口里的call方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现Future接口，
    并实现了Runnable接口—可以作为Thread的target。
 
    Future接口里定义了如下几个公共方法控制他关联的Callable任务：
    
    A、boolean cancel(Boolean mayInterruptlfRunning):试图取消该Future里关联的Callable任务
    B、V get()：返回Callable任务里的call方法的返回值，调用该方法将导致线程阻塞，必须等到子线程结束才得到返回值
    C、V get(long timeout, TimeUnit unit)：返回Callable任务里的call方法的返回值，该方法让程序最多阻塞timeout和unit指定的时间。
        如果经过指定时间后Callable任务依然没有返回值，将会抛出TimeoutException。
    D、boolean isCancelled：如果在Callable任务正常完成前被取消，则返回true。
    E、boolean isDone：如果Callable任务已经完成，则返回true
 
    创建、并启动有返回值的线程的步骤如下：
    
    一、创建Callable接口的实现类，并实现call方法，该call方法的返回值，并作为线程的执行体。
    二、创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call方法的返回值
    三、使用FutureTask对象作为Thread对象的target创建、并启动新线程
    四、调用FutureTask对象的方法来获得子线程执行结束后的返回值

1、Executor框架使用Runnable作为其任务的基本表达形式。Runnable相当有限，不能返回一个值，也不能抛出受检查的异常，对于复杂费时的计算更加无法处理

2、因此产生了Callable和Future这种任务，对任务进行全面管理


3、


1）Callable在主进入点-call处等待返回值，并为可能抛出的异常预先做了准备。


2）Executors包含了一些工具方法将其他类型的任务封装成一个Callable，比如Runnable和java.security.PrivilegedAction。Runnable和Callable描述的是抽象的计算型任务。


3）这些任务很有限，有明确的开始和结束，但是对于非常费时的任务比较麻烦，对于已经提交但尚未开始的任务可以取消，但是对于已经开始的任务，只有它们响应中断，才可以取消。


4、


1）Future描述了任务的生命周期，并提供了相关的方法来获得任务的结果、取消任务以及检验任务已经完成还是被取消。


2）Future意味着任务完成后永远停留在完成状态上，就像ExecutorService的生命周期。使用get方法完成任务和异常处理。

3）ExecutorService中的所有submit方法都返回一个Future，可以将一个Runnable或一个Callable提交给executor,然后得到一个Future。也可以显式地为给定的Runnable或Callable实例化一个FutureTask。

[java]  view plain copy print ?

1. package com.itm.thread;  
2.   
3. import java.util.Random;  
4. import java.util.concurrent.Callable;  
5. import java.util.concurrent.CompletionService;  
6. import java.util.concurrent.ExecutionException;  
7. import java.util.concurrent.ExecutorCompletionService;  
8. import java.util.concurrent.ExecutorService;  
9. import java.util.concurrent.Executors;  
10. import java.util.concurrent.Future;  
11.   
12. import javax.annotation.processing.Completion;  
13.   
14. public class CallableAndFuture {  
15.   
16.     /** 
17.      * @param args 
18.      */  
19.     public static void main(String[] args) {  
20.         ExecutorService threadPool = Executors.newSingleThreadExecutor();  
21.         Future<String> future =   
22.         threadPool.submit(  
23.                 new Callable<String>(){  
24.                         public String call() throws Exception {  
25.                             Thread.sleep(2000);  
26.                             return "hello";  
27.                         };  
28.                 }  
29.         );  
30.         System.out.println("等待结果");  
31.         try {  
32.             System.out.println("拿到结果  : " + future.get());  
33.         } catch (InterruptedException e) {  
34.             e.printStackTrace();  
35.         } catch (ExecutionException e) {  
36.             e.printStackTrace();  
37.         }  
38.           
39.         /********** 
40.          *  
41.          * 第二种   方法： 
42.          *  
43.          */  
44.         ExecutorService threadPool2 = Executors.newFixedThreadPool(10);  
45.         CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool2);  
46.           
47.         // 提交十个任务。  
48.         for(int i=1;i<=10;i++){  
49.                 final int seq = i;  
50.                 completionService.submit(new Callable<Integer>() {  
51.                     @Override  
52.                     public Integer call() throws Exception {  
53.                         Thread.sleep(new Random().nextInt(5000));  
54.                         return seq;  
55.                     }  
56.                 });  
57.         }  
58.         // 拿到  提交任务的结果  。。。  
59.         for(int i=0;i<10;i++){  
60.             try {  
61.                 System.out.println(  
62.                 completionService.take().get());  
63.             } catch (InterruptedException e) {  
64.                 // TODO Auto-generated catch block  
65.                 e.printStackTrace();  
66.             } catch (ExecutionException e) {  
67.                 // TODO Auto-generated catch block  
68.                 e.printStackTrace();  
69.             }  
70.         }  
71.     }  
72.       
73.   
74. }  

也可以借鉴一下：

[java]  view plain copy print ?

1. import java.util.concurrent.Callable;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. import java.util.concurrent.Future;  
5.    
6. /** 
7.     从本节开始,主要介绍J2SE5.0与线程相关的新特性,新的线程类主要集中在java.util.concurrent 
8. 包中,本节实例将介绍如何使用java.util.concurrent.Callable和java.util.concurrent.Future类, 
9. 用Callable定义一个任务并启动它,然后用它的Future获取输出结果并停止它. 
10. 关键技术剖析: 
11.     关于Callable和Future类的关键技术如下: 
12.     1.Callable是类似于Runnable的接口,实现Callable接口的类和实现Runable的类都是可被其他线程 
13. 执行的任务. 
14.     2.Callable和Runnable的区别如下: 
15.         1)Callable定义的方法是call,而Runnable定义的方法是run. 
16.         2)Callable的call方法可以有返回值,而Runnable的run方法不能有返回值 
17.         3)Callable的call方法可抛出异常,而Runnable的run方法不能抛出异常 
18.     3.Future表示异步计算的结果,它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的 
19. 结果.Future的cancel方法取消任务的执行,有一个布尔参数,参数为true表示立即中断任务的执行,参数 
20. 为false表示允许正在运行的任务运行完成.Future的get方法等待计算完成,获取计算结果. 
21.  */  
22. public class CallableAndFuture {  
23.        /**自定义一个任务类,实现Callable接口*/  
24.        public static class MyCallableClass implements Callable{  
25.               private int flag = 0;  
26.               public MyCallableClass(int flag){  
27.                      this.flag = flag;  
28.               }  
29.               public String call() throws Exception{  
30.                      if(this.flag == 0){  
31.                             return "flag = 0";//如果flag的值为0,则立即返回  
32.                      }  
33.                      if(this.flag == 1){  
34.                             //如果flag的值为1,做一个无限循环  
35.                             try{  
36.                                    while(true){  
37.                                           System.out.println("looping...");  
38.                                           Thread.sleep(2000);  
39.                                    }  
40.                             }catch(InterruptedException e){  
41.                                    System.out.println("Interrupted");  
42.                             }  
43.                             return "false";  
44.                      }else{  
45.                             throw new Exception("Bad flag value!");//flag不为1或0,则抛出异常  
46.                      }  
47.               }  
48.        }  
49.        public static void main(String... args){  
50.               //定义3个Callable类型的任务  
51.               MyCallableClass task1 = new MyCallableClass(0);  
52.               MyCallableClass task2 = new MyCallableClass(1);  
53.               MyCallableClass task3 = new MyCallableClass(2);  
54.                
55.               //创建一个执行任务的服务  
56.               ExecutorService es = Executors.newFixedThreadPool(3);  
57.               try{  
58.                      //提交并执行任务,任务启动时返回了一个Future对象  
59.                      //如果想得到任务执行的结果或者是异常可对这个Future对象进行操作  
60.                      Future future1 = es.submit(task1);  
61.                      //获得第一个任务的结果,如果调用get方法,当前线程会等待任务执行完毕后才往下执行  
62.                      System.out.println("task1: " + future1.get());  
63.                       
64.                      Future future2 = es.submit(task2);  
65.                      //等待5秒后,再停止第二个任务,因为第二个任务进行的是无限循环  
66.                      Thread.sleep(5000);  
67.                      System.out.println("task2 cancel: " + future2.cancel(true));  
68.                       
69.                      //获取第三个任务的输出,因为执行第三个任务会引起异常  
70.                      //所以下面的语句将引起异常的输出  
71.                      Future future3 = es.submit(task3);  
72.                      System.out.println("task3: " + future3.get());  
73.               }catch(Exception e){  
74.                      System.out.println(e.toString());  
75.               }  
76.               es.shutdown();//立即停止任务执行服务  
77.        }  
78. }