使用Java的Callable接口运行线程

Runnable和Callable的区别:
(1)Runnable是自从java1.1就有了，而Callable是1.5之后才加上去的
(2)Callable规定的方法是call(),Runnable规定的方法是run()
(3)Callable的任务执行后可返回值，而Runnable的任务是不能返回值(是void)
(4)call方法可以抛出异常，run方法不可以
(5)运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。
(6)加入线程池运行，Runnable使用ExecutorService的execute方法，Callable使用submit方法。

Callable接口也是位于java.util.concurrent包中。Callable接口的定义为：

 

public interface Callable<V>   
{   
    V call() throws Exception;   
} 

 

 测试使用代码，定义一个实现Callable接口的类OneTask：

 

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函数是没有返回值的
	} 
}

 执行Callable的线程的方法可以借助FutureTask或者加入到线程池中。首先看怎么用FutureTash执行，代码如下：

 

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

 

 参考http://www.cnblogs.com/yjl49/archive/2012/09/26/2704274.html，FutureTash扮演监督的角色，主线程通过不断询问实现Callable的类对应的线程是否执行完毕，最后可以得到返回的结果。通过线程池的方式如下：

 

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

 线程池的submit方法会返回一个Future，通过这个Future可以判断线程是否执行完毕，已经通过它可以得到返回值。