Java并发编程高级篇(三)：执行器中执行任务并返回结果

执行器框架的优质之一是可以并发地执行任务，并将任务执行结果返回。要想实现这个功能，需要JDK中的两个接口。

• Callable：这个接口带有一个call()方法，你可以在这个方法里面实现任务执行逻辑，同时这个接口带有一个泛型参数，你可以通过这个泛型参数来指定返回结果的类型。
• Future：这个接口生命了一些方法来获取由Callable对象产生的结果，并管理他们的状态。

创建一个类FactorialCalculator实现Callable接口，用于计算阶乘。泛型参数使用Integer来规定返回值为整型。

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * 创建一个名为FactorialCalculator类并实现Callable<Integer>接口
 *
 * 用来计算number的阶乘
 *
 * Created by hadoop on 2016/11/2.
 */
public class FactorialCalculator implements Callable<Integer> {
    private Integer number;

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

    @Override
    public Integer call() throws Exception {
        int result = 1;

        if (number > 2) {
            for (int i = 2; i <= number; i++) {
                result *= i;
            }
        }

        TimeUnit.MILLISECONDS.sleep(200);

        return result;
    }
}

然后实现Main方法，循环10次，每次产生一个随机整数，然后调用FactorialCalculator来求这个整数的阶乘。注意这里使用submit()方法来提交callable任务，因为这个方法会返回一个Future对象，而不是前面两节那样使用的是execute方法来执行Runnable。

使用Futuee对象不但可以用来获取线程任务的返回值，还可以用于获取线程执行状态。

• isDone()：用于检查任务是否执行完成。
• get()：用于获取Callable的call()方法执行的返回结果，get()方法将一直等待call()方法执行完成。如果等待过程中线程中断了，那么将抛出InterrupedException异常，如果call()方法执行异常，那么get()方法将接着抛出ExecutionException。
• get(long timeout, TimeUnit unit)：等待一段时间，如果任务没有执行完毕，那么返回null。

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.*;

/**
 * 在执行器中执行任务并返回结果
 *
 * 执行器框架的优势之一在于可以并行执行任务，并且返回结果。Java并发API通过以下两个接口来s实现这个功能。
 * 1. Callable接口：这个借口生命了call()方法，你可以在这个方法中实现具体的处理逻辑。
 *    Callable接口带有泛型参数，这意味着call()方法可以返回该数据类型的对象。
 * 2. Future接口：这个接口用来接收Callable接口产生的结果，并管理他们的状态。
 *
 * 在本节我们学习了使用Callable接口来启动并发任务并返回结果。
 * 我么编写了FactorialCalculator类，它实现了带有泛型参数Integer的Callable接口。
 * 因此这个Integer类型将作为在调用call()方法的返回值类型。
 *
 * 另一个关键点在于Main类，在这个类中我们使用了submit()方法，发送一个Callable对象到执行器中。
 * 这个submit()方法接收Callable对象作为参数，然后返回Future对象。
 * Future对象可以用于以下两个目的。
 * 1. 控制任务的状态：可以取消或者检查任务是否完成。在这里我们使用了isDone方法来判断任务是否完成。
 * 2. 通过get()方法，接收call()方法返回的结果。这个方法一直等到call()方法执行完成并返回结果。
 *    如果get()方法在等待结果时线程中断了，将抛出一个InterruptedException。
 *    如果call()方法抛出异常，那么get方法抛出ExecutionException。
 *
 * Future对象还听了另一个future.get(1000, TimeUnit.NANOSECONDS)方法来接受返回值。
 * 如果等待(1000, TimeUnit.NANOSECONDS)时间，call()方法还没有执行结束，那么将直接返回null值。
 *
 * Created by hadoop on 2016/11/2.
 */
public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newFixedThreadPool(2);

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

        Random random = new Random();

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

            FactorialCalculator calculator = new FactorialCalculator(number);

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

            futures.add(future);
        }

        do {
            //System.out.printf("Main: Number of the completed Tasks: %d\n", executor.getCompletedTaskCount());

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

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

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

        for (int i = 0; i < futures.size(); i++) {
            Future<Integer> future = futures.get(i);
            System.out.printf("Main: Tasks %d: %d\n", i, future.get());
            //System.out.printf("Main: Tasks %d: %d\n", i, future.get(1000, TimeUnit.NANOSECONDS));
        }

        executor.shutdown();
    }
}