Java 7：如何批量执行并行任务？

我有三个可以并行运行的web服务调用。因此，我使用3个线程的固定池来运行它们

现在，我想处理更多的web服务调用，这些调用可以并行运行，但只有在处理前三个调用之后

我怎样才能批量生产？我希望批处理中的那些并行运行。每个批次仅在前一批次完成后运行

到目前为止，我只与三个服务。如何对它们进行批处理并开始使用另外2个服务

  ExecutorService peopleDataTaskExecutor = Executors.newFixedThreadPool(3);

  Future<Collection<PeopleInterface>> task1 = null;
  if (condition) { 
      task1 = peopleDataTaskExecutor.submit(buildTask1Callable(mycontext));
  }

  Future<Map<String, Task2Response>> task2 = peopleDataTaskExecutor.submit(buildTask2Callable(mycontext));

  Future<Map<String, Task3Response>> task3 = null;
  task3 = peopleDataTaskExecutor.submit(buildTask3Callable(mycontext));

  peopleDataTaskExecutor.shutdown();
  try {
      peopleDataTaskExecutor.awaitTermination(10, TimeUnit.SECONDS); 
  } catch (InterruptedException e) {
  }

  Collection<PeopleInterface> task1Data = null;
  try {
      task1Data = task1 != null ? task1.get() : null;
  } catch (InterruptedException | ExecutionException e) {
  }

  Map<String, Task2Response> task2Data = null;
  try {
      task2Data = task2.get();
  } catch (InterruptedException | ExecutionException e) {
  }

  Map<String, Task3Response> task3Data = null;
  if (task3 != null) {
      try {
          task3Data = task3.get();
      } catch (InterruptedException | ExecutionException e) {
      }
  }

ExecutorService peopleDataTaskExecutor=Executors.newFixedThreadPool（3）；
Future task1=null；
如果（条件）{
task1=peopleDataTaskExecutor.submit（buildTask1Callable（mycontext））；
}
Future task2=peopleDataTaskExecutor.submit（buildTask2Callable（mycontext））；
Future task3=null；
task3=peopleDataTaskExecutor.submit（buildTask3Callable（mycontext））；
peopleDataTaskExecutor.shutdown（）；
试一试{
peopleDataTaskExecutor.等待终止（10，时间单位：秒）；
}捕捉（中断异常e）{
}
集合task1Data=null；
试一试{
task1Data=task1！=null？task1.get（）：null；
}捕获（中断异常|执行异常e）{
}
Map task2Data=null；
试一试{
task2Data=task2.get（）；
}捕获（中断异常|执行异常e）{
}
Map task3Data=null；
如果（task3！=null）{
试一试{
task3Data=task3.get（）；
}捕获（中断异常|执行异常e）{
}
}

顺序执行批处理的最简单方法是使用

invokeAll（）

方法。它接受一组任务，将它们提交给执行者，并等待完成（或超时过期）。下面是一个简单的示例，它按顺序执行三个批处理。每个批包含三个并行运行的任务：

public class Program {
    static class Task implements Callable<Integer> {
        private static Random rand = new Random();
        private final int no;
        Task(int no) {
            this.no = no;
        }
        @Override
        public Integer call() throws Exception {
            Thread.sleep(rand.nextInt(5000));
            System.out.println("Task " + no + " finished");
            return no;
        }
    }

    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        processBatch(executor, 1);
        processBatch(executor, 2);
        processBatch(executor, 3);
        executor.shutdown();
    }

    private static void processBatch(ExecutorService executor, int batchNo) throws InterruptedException {
        Collection batch = new ArrayList<>();
        batch.add(new Task(batchNo * 10 + 1));
        batch.add(new Task(batchNo * 10 + 2));
        batch.add(new Task(batchNo * 10 + 3));
        List<Future> futures = executor.invokeAll(batch);
        System.out.println("Batch " + batchNo + " proceseed");
    }
}

公共类程序{
静态类任务实现了可调用{
私有静态随机兰德=新随机（）；
私人最终国际编号；
任务（内部编号）{
这个。否=否；
}
@凌驾
公共整数调用（）引发异常{
线程睡眠（兰特nextInt（5000））；
System.out.println（“任务”+no+“完成”）；
返回否；
}
}
公共静态void main（字符串[]args）引发异常{
ExecutorService executor=Executors.newFixedThreadPool（3）；
processBatch（执行器，1）；
processBatch（执行器，2）；
processBatch（执行者，3）；
executor.shutdown（）；
}
私有静态void processBatch（ExecutorService executor，int batchNo）抛出InterruptedException{
集合批处理=新建ArrayList（）；
批量添加（新任务（批次号*10+1））；
批量添加（新任务（批次号*10+2））；
批量添加（新任务（批次号*10+3））；
列表期货=executor.invokeAll（批处理）；
System.out.println（“批次”+batchNo+procesed”）；
}
}

---

您可以在

processBatch（）

方法中使用这些

Future

s来检查任务的完成状态（任务是否成功执行或由于异常而终止）、获取其返回值等。

添加批处理时是否有方法获取未来？否则，从列表到索引获取未来的逻辑看起来很混乱。如果添加一个批，则会得到一个未来集合。只能通过调用“submit（）”获取一个未来。但在后一种情况下，您有责任等待每个未来，直到它完成或超时过期。因此，如果您有一组任务，那么您必须以任何一种方式迭代它们的未来

invokeAll（）

更简单，因为它不会强制您在提交时进行迭代。使用

submit（）

时，您必须迭代两次，以提交任务和处理结果。