Java并发编程高级篇(五)：运行多个任务并处理所有结果

执行器框架给我们提供了一个方法，让我们可以发送给执行器一个任务列表，并等待任务列表中的所有任务执行完毕。然后它将返回一个与任务列表对应的Future列表。

下面我们来看一下这个invokeAll方法怎么用。

首先我们创建一个Result类，用于保存任务执行结果。

/**
 * 创建Result类，作为Callable接口实现call()方法的返回值类型
 *
 * Created by hadoop on 2016/11/2.
 */
public class Result {
    private String name;
    private int value;

    public Result(String name, int value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public int getValue() {
        return value;
    }
}

接下来我们实现Callable接口，然后实现任务逻辑。随机等待一段时间来模拟任务的执行过程，然后求得一个随机数，并返回Result。

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

/**
 * Created by hadoop on 2016/11/2.
 */
public class Task implements Callable<Result> {
    private String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public Result call() throws Exception {
        long duration = (long) (Math.random() * 10);

        System.out.printf("%s: Starting and Waiting %d seconds for results.\n", this.name, duration);

        TimeUnit.SECONDS.sleep(duration);

        int value = 0;

        for (int i = 0; i < 5; i++) {
            value += (int) (Math.random() * 100);
        }

        return new Result(this.name, value);
    }
}

最后看一下主方法类，我们创建三个任务实例，并加入到任务列表中。然后调用invokeAll方法来执行这个任务列表，并接受一个Future列表返回值，并打印返回值结果。

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

/**
 * 运行多个任务并处理全部结果
 *
 * 该范例的关键点在于调用了ExecutorService的invokeAll()方法。
 * 这个方法接收一个实现了Callable接口的任务列表，然后等待所有任务完成，并返回一个Future列表。
 *
 * Created by hadoop on 2016/11/2.
 */
public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();

        List<Task> tasks = new ArrayList<Task>();

        for (int i = 0; i < 3; i++) {
            tasks.add(new Task(String.valueOf(i)));
        }

        try {
            List<Future<Result>> futures = executor.invokeAll(tasks);
            //List<Future<Result>> futures = executor.invokeAll(tasks, 2, TimeUnit.SECONDS);

            executor.shutdown();

            System.out.printf("Main: Start print resutls\n");

            for (Future<Result> future : futures) {
                System.out.printf("%s : %s\n", future.get().getName(), future.get().getValue());
                //System.out.println(future.isCancelled());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.printf("Main: End of programe.\n");
    }
}