使用ExecutorService、Callable、Future实现有返回结果的线程

 可返回值的任务必须实现Callable接口
无返回值的任务必须实现Runnable接口
执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object
注意：get方法是阻塞的，即：线程无返回结果，get方法会一直等待

 

例子1：

/** 
* 有返回值的线程 
*/  
@SuppressWarnings("unchecked")  
public class Test {  
public static void main(String[] args) throws ExecutionException,  
    InterruptedException {  
   System.out.println("----程序开始运行----");  
   Date date1 = new Date();  
  
   int taskSize = 5;  
   // 创建一个线程池  
   ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
   // 创建多个有返回值的任务  
   List<Future> list = new ArrayList<Future>();  
   for (int i = 0; i < taskSize; i++) {  
    Callable c = new MyCallable(i + " ");  
    // 执行任务并获取Future对象  
    Future f = pool.submit(c);  
    // System.out.println(">>>" + f.get().toString());  
    list.add(f);  
   }  
   // 关闭线程池  
   pool.shutdown();  
  
   // 获取所有并发任务的运行结果  
   for (Future f : list) {  
    // 从Future对象上获取任务的返回值，并输出到控制台  
    System.out.println(">>>" + f.get().toString());  
   }  
  
   Date date2 = new Date();  
   System.out.println("----程序结束运行----，程序运行时间【"  
     + (date2.getTime() - date1.getTime()) + "毫秒】");  
}  
}  
  
class MyCallable implements Callable<Object> {  
private String taskNum;  
  
MyCallable(String taskNum) {  
   this.taskNum = taskNum;  
}  
  
public Object call() throws Exception {  
   System.out.println(">>>" + taskNum + "任务启动");  
   Date dateTmp1 = new Date();  
   Thread.sleep(1000);  
   Date dateTmp2 = new Date();  
   long time = dateTmp2.getTime() - dateTmp1.getTime();  
   System.out.println(">>>" + taskNum + "任务终止");  
   return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";  
}  
} 

例子2：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorCallableTest {
	public static void main(String[] args) {
		//创建一个线程池
		ExecutorService pools = Executors.newFixedThreadPool(5);
		List<Future<Integer>> list = new ArrayList<Future<Integer>>();
		//创建多个有返回值的任务
		for(int i = 0 ; i <= 10 ; i++){
			Future<Integer> futures = pools.submit(new Task(i));
			list.add(futures);
		}
		for(Future<Integer> f : list){
			try {
				System.out.println(f.get());
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		}
		pools.shutdown();
	}
}
class Task implements Callable<Integer>{
	private Integer taskID;
	public Task(Integer taskID) {
		this.taskID = taskID;
	}
	public Integer call() throws Exception {
		if(taskID.equals(3))
			Thread.sleep(10000);
		System.out.println("任务["+taskID+"]开始执行");
		return taskID;
	}
}

任务[1]开始执行
任务[2]开始执行
任务[0]开始执行
任务[4]开始执行
任务[6]开始执行
任务[9]开始执行
任务[10]开始执行
任务[5]开始执行
0
1
2
任务[8]开始执行
任务[7]开始执行
任务[3]开始执行
3
4
5
6
7
8
9
10

例子3：

通过ExecutorCompletionService实现任务结果的获取，可以实现将完成的任务先获取。按照这些任务的完成的时间顺序来处理他们的结果。

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorCallableTest {
	public static void main(String[] args) {
		//创建一个线程池
		ExecutorService pools = Executors.newFixedThreadPool(5);
		CompletionService<Integer> s = new ExecutorCompletionService<Integer>(pools);
		//创建多个有返回值的任务
		for(int i = 0 ; i <= 10 ; i++){
			s.submit(new Task(i));
		}
		for(int i = 0 ; i <= 10 ; i++){
			try {
				Future<Integer> f = s.take();
				System.out.println(f.get());
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		}
		pools.shutdown();
	}
}
class Task implements Callable<Integer>{
	private Integer taskID;
	public Task(Integer taskID) {
		this.taskID = taskID;
	}
	public Integer call() throws Exception {
		if(taskID.equals(3))
			Thread.sleep(10000);
		System.out.println("任务["+taskID+"]开始执行");
		return taskID;
	}
}

任务[1]开始执行
任务[4]开始执行
任务[5]开始执行
任务[6]开始执行
任务[0]开始执行
任务[2]开始执行
任务[9]开始执行
任务[8]开始执行
任务[7]开始执行
4
1
任务[10]开始执行
5
6
0
2
9
8
7
10
任务[3]开始执行
3