java1.5之Callable

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();      
    }  
}