Callable从任务中产生返回值

Runnable是执行工作的独立任务，但是它不返回值。如果希望任务在完成时能够返回一个值，那么就可以实现Callable接口而不是Runnable接口。Callable是一种具有类型参数的泛型，它的类型参数表示的是从方法call()（而不是run())中返回的值，并且必须使用ExecutorService.submit()方法调用它。

import java.util.ArrayList;
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 CallableDemo {
	public static void main(String[] args) {
		ExecutorService exec = Executors.newCachedThreadPool();
		ArrayList<Future<String>> results = new ArrayList<Future<String>>();
		for(int i=0;i<10;i++)
			results.add(exec.submit(new TaskWithResult(i)));
		for (Future<String> future : results) {
		
				try {
					System.out.println(future.get());
				} catch (InterruptedException | ExecutionException e) {
					e.printStackTrace();
				}finally{
					exec.shutdown();
				}
			
		}
	}
}
class TaskWithResult implements Callable<String>{
	private int id;
	public TaskWithResult(int id){
		this.id = id;
	}
	@Override
	public String call()throws Exception  {
		return "result = "+id;
	}
}

submit()方法会产生Future对象，它用Callable返回的结果的特定类型进行了参数化。 Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。 

可以用isDone()方法来查询Future是否已经完成。当任务完成时，它具有一个结果，可以调用get()方法来获取该结果。如果直接调用get()的话，当没有计算完毕时，会被阻塞，直至结果准备就绪。

实例2：

package chapter3;


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 MultithreadMaxFinder {
public static void main(String[] args) {
int[] data = {9,2,5,4};
System.out.println(max(data));
}
public static int max(int[] data) {
if(data.length==1) return data[0];
if(data.length==0)throw new IllegalArgumentException();
FindMaxTask task1 = new FindMaxTask(data,0,data.length/2);
FindMaxTask task2 = new FindMaxTask(data,data.length/2,data.length);
//创建2个线程
ExecutorService service = Executors.newFixedThreadPool(2);
Future<Integer> future1 = service.submit(task1);
Future<Integer> future2 = service.submit(task2);
int max = -1;
try {
max = Math.max(future1.get(), future2.get());
} catch (InterruptedException | ExecutionException e) {
service.shutdown();
e.printStackTrace();
}
service.shutdown();
return max;
}
}
class FindMaxTask implements Callable<Integer>{
private int[] data;
private int start;
private int end;
public FindMaxTask(int[] data, int start, int end){
this.data = data;
this.start = start;
this.end = end;
}
@Override
public Integer call()throws Exception {
int max = Integer.MIN_VALUE;
for(int i=start;i<end;i++){
if(data[i]>max) max = data[i];
}
return max;
}

}