线程执行者（四）执行者执行返回结果的任务-CSDN博客

执行者执行返回结果的任务

Executor framework的一个优点是你可以并发执行返回结果的任务。Java并发API使用以下两种接口来实现：

Callable：此接口有一个call()方法。在这个方法中，你必须实现任务的（处理）逻辑。Callable接口是一个参数化的接口。意味着你必须表明call()方法返回的数据类型。
Future：此接口有一些方法来保证Callable对象结果的获取和管理它的状态。

在这个指南中，你将学习如何实现返回结果的任务，并在执行者中运行它们。

准备工作…

这个指南的例子使用Eclipse IDE实现。如果你使用Eclipse或其他IDE，如NetBeans，打开它并创建一个新的Java项目。

如何做…

按以下步骤来实现的这个例子:

1.创建FactorialCalculator类，指定它实现Callable接口，并参数化为Integer类型。

public class FactorialCalculator implements Callable<Integer> {

2.声明一个私有的，类型为Integer，名为number的属性，用来存储任务将要计算出的数。

private Integer number;

3.实现FactorialCalculator构造器，初始化这个属性。

public FactorialCalculator(Integer number){
this.number=number;
}

4.实现call()方法。这个方法将返回FactorialCalculator的number属性的阶乘。

@Override
public Integer call() throws Exception {

5.首先，创建和初始化在这个方法中使用的局部变量。

int result = 1;

6.如果数是1或0，则返回1。否则，计算这个数的阶乘。出于教学目的，在两次乘之间，令这个任务睡眠20毫秒。

if ((num==0)||(num==1)) {
result=1;
} else {
for (int i=2; i<=number; i++) {
result*=i;
TimeUnit.MILLISECONDS.sleep(20);
}
}

7.操作结果的信息写入控制台。

System.out.printf("%s: %d\n",Thread.currentThread().getName(),result);

8.返回操作结果。

return result;

9.实现这个示例的主类，创建Main类，实现main()方法。

public class Main {
public static void main(String[] args) {

10.使用Executors类的newFixedThreadPool()方法创建ThreadPoolExecutor来运行任务。传入参数2。

ThreadPoolExecutor executor=(ThreadPoolExecutor)Executors.newFixedThreadPool(2);

11.创建Future<Integer>对象的数列。

List<Future<Integer>> resultList=new ArrayList<>();

12.创建Random类产生的随机数。

Random random=new Random();

13.生成0到10之间的10个随机数。

for (int i=0; i<10; i++){
Integer number= random.nextInt(10);

14.创建一个FactorialCaculator对象，传入随机数作为参数。

FactorialCalculator calculator=new FactorialCalculator(number);

15.调用执行者的submit()方法来提交FactorialCalculator任务给执行者。这个方法返回Future<Integer>对象来管理任务，并且最终获取它的结果。

Future<Integer> result=executor.submit(calculator);

16.添加Future对象到之前创建的数列。

resultList.add(result);
}

17.创建一个do循环来监控执行者的状态。

do {

18.首先，写入信息到控制台，表明使用执行者的getCompletedTaskNumber()方法获得的已完成的任务数。

System.out.printf("Main: Number of Completed Tasks:%d\n",executor.getCompletedTaskCount());

19.然后，对于数列中的10个Future对象，使用isDone()方法，将信息写入（到控制台）表明它们所管理的任务是否已经完成

for (int i=0; i<resultList.size(); i++) {
Future<Integer> result=resultList.get(i);
System.out.printf("Main: Task %d: %s\n",i,result.isDone());
}

20.令这个线程睡眠50毫秒

try {
TimeUnit.MILLISECONDS.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}

21.如果执行者中的已完成任务数小于10，重复这个循环。

} while (executor.getCompletedTaskCount()<resultList.size());

22.将获得的每个任务的结果写入控制台。对于每个Future对象，通过它的任务使用get()方法获取返回的Integer对象。

System.out.printf("Main: Results\n");
for (int i=0; i<resultList.size(); i++) {
Future<Integer> result=resultList.get(i);

Integer number=null;
try {
number=result.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}

23.然后，在控制台打印这个数。

System.out.printf("Main: Task %d: %d\n",i,number);
}

24.最后，调用执行者的shutdown()方法来结束这个执行者。

executor.shutdown();

它是如何工作的…

在这个指南中，你已经学习了如何使用Callable接口来启动返回结果的并发任务。你已经使用FactorialCalculator类实现了Callable接口，并参数化为Integer类型作为结果类型。因此，Integer就作为call()方法的返回类型。

Main类是这个示例的另一个关键点。它使用submit()方法提交一个Callable对象给执行者执行。这个方法接收Callable对象参数，并且返回一个Future对象，你可以以这两个目标来使用它：

你可以控制任务的状态：你可以取消任务，检查任务是否已经完成。基于这个目的，你已经使用isDone()方法来检查任务是否已经完成。
你可以获取call()方法返回的结果。基于这个目的，你已经使用了get()方法。这个方法会等待，直到Callable对象完成call()方法的执行，并且返回它的结果。如果线程在get()方法上等待结果时被中断，它将抛出InterruptedException异常。如果call()方法抛出异常，这个方法会抛出ExecutionException异常。

不止这些…

当你调用Future对象的get()方法，并且这个对象控制的任务未完成，这个方法会阻塞直到任务完成。Future接口提供其他版本的get()方法：

get(long timeout, TimeUnit unit)：这个版本的get方法，如果任务的结果不可用，等待它在指定的时间内。如果时间超时，并且结果不可用，这个方法返回null值。 TimeUnit类是个枚举类，有如下常量：DAYS，HOURS，MICROSECONDS， MILLISECONDS， MINUTES,，NANOSECONDS 和SECONDS。

参见