java1.5之Callable

系统管理员 2021-06-24 14:34 233阅读 0赞

JDK5中的一个亮点就是将Doug Lea的并发库引入到Java标准库中。在java.util.concurrent包下除了有locks、atomic、并发集合(ConcurrentHashMap、CopyOnWriteArrayList等)，还有线程池(Executor)、Callable等并发工具。  
  
  
1、在jdk1.5以后，可以通过Callable接口运行线程，他和Runnable接口区别：  
• Runnable是自从java1.1就有了，而Callable是1.5之后才加上去的；  
• Callable规定的方法是call(),Runnable规定的方法是run()；  
• Callable的任务执行后可返回值，而Runnable的任务是不能返回值(是void)；  
• call方法可以抛出异常，run方法不可以；  
• 运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果；  
• 加入线程池运行，Runnable使用ExecutorService的execute方法，Callable使用submit方法。  
  
  
Callable接口也是位于java.util.concurrent包中。Callable接口的定义为：  
public interface Callable<V>   \{       
    V call() throws Exception;       
\}  
  
  
2、执行Callable的线程的方法可以通过以下两种方式：  
1. 借助FutureTask，使用Thread的start方法来执行；  
2. 加入到线程池中，使用线程池的execute或submit执行；  
  
详情见下面实例1。。。

3、通过Executors工具类可以把Runnable接口转换成Callable接口。

实例：

1）定义一个实现Callable接口的类：

import java.util.concurrent.Callable;  
      
    public class OneTask implements Callable<String> {//callable有个<V>,这个V就是call函数的返回值类型  
        private int id;  
        public OneTask(int id){  
            this.id = id;  
        }  
        @Override  
        public String call() throws Exception {//这儿可以抛出异常，而Runnable接口的run函数不可以  
            int i=5;  
            while (i>=0) {  
                System.out.println("Thread "+ id +" is working");  
                Thread.sleep(1000);  
                i--;  
            }  
            return "result of Test2 " + id; //Runnable接口的run函数是没有返回值的  
        }   
    }

2）通过FutureTask执行线程方法：

import java.util.concurrent.Callable;  
    import java.util.concurrent.FutureTask;  
       
    public class Test1 {   
           
        public static void main(String[] args) {  
            Callable<String> oneCallable = new OneTask(1);  
            FutureTask<String> ft= new FutureTask<String>(oneCallable);  
            //FutureTask<String>是一个包装器，它通过接受Callable<String>来创建，它同时实现了Future和Runnable接口  
              
            new Thread(ft).start();  
          
            while(!ft.isDone()){  
                try {  
                    System.out.println("检查线程执行完了吗...");  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {   
                    e.printStackTrace();  
                }  
            }  
              
            String result = "";  
            try {  
                result = ft.get();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            System.out.println(result);  
        }  
    }

3）通过线程池执行：

import java.util.ArrayList;   
    import java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
    import java.util.concurrent.Future;  
      
    public class Test3 {  
      
        public static void main(String[] args){  
            // TODO Auto-generated method stub  
            ExecutorService exec = Executors.newCachedThreadPool();    
            ArrayList<Future<String>> results = new ArrayList<Future<String>>();      
            //Future 相当于是用来存放Executor执行的结果的一种容器    
              
            for (int i = 0; i < 10; i++) {    
                results.add(exec.submit(new OneTask(i)));    
            }    
              
            for (Future<String> fs : results) {    
                if (fs.isDone()) {    
                    try {  
                        System.out.println(fs.get());   
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                } else {    
                    System.out.println("Future result is not yet complete");    
                }    
            }    
            exec.shutdown();      
        }  
    }