使用ExecutorService并行重复执行多个类似的任务

Question

有一个Java代码，简化后看起来像这样：

while(someCondition)
{
    SomeType a = CalcResult(param1);
    SomeType b = CalcResult(param2);
    SomeType c = CalcResult(param3);
    // Do something with a, b and c
}

CCD_ 1非常耗时。应用程序在SMP系统上运行。尝试在自己的CPU上同时运行所有三个计算，而不是按顺序运行。总是这3个任务需要并行，而不是任意数量的任务（这就是算法）。每项任务可能比其他任务花费更多或更少的时间，但通常差异不大（20-30%）。

由于他们需要返回结果，我从https://stackoverflow.com/a/9148992/2721750:

ExecutorService executor = Executors.newSingleThreadExecutor();
Callable<Integer> callable = new Callable<Integer>() {
    @Override
    public Integer call() {
        return 2;
    }
};
Future<Integer> future = executor.submit(callable);
// future.get() returns 2
executor.shutdown();

由于我在Java方面的经验主要是在servlet/JSP开发方面，所以我没有线程方面的经验，也不确定这个片段是否能处理3个任务而不是一个任务。

我如何提交3个任务，每个任务都有自己的参数值，并等待所有任务都返回计算结果，同时确保为它们创建线程不会抵消在自己的CPU上运行的优势，即是否有方法在while()循环strats之前创建一次线程，然后简单地将一个新的paramN推到循环中的每个线程中，唤醒它们，然后等待它们执行所有计算？

Answer 1

Executors.newSingleThreadExecutor()将只创建一个线程。你想要的是Executors.newFixedThreadPool(3)。在while循环之前调用此函数，因此线程只创建一次。

创建可调用包装：

class MyCallable implements Callable<V> {
    P p;
    MyCallable(P parameter) {
        p = parameter;
    }
    V call() {
        return CalcResult(p);
    }
}

while loop:

ExecutorService executor = Executors.newFixedThreadPool(3);
while (cond) {
    Future<V> aFuture = executor.submit(new MyCallable(param1));
    Future<V> bFuture = executor.submit(new MyCallable(param2));
    Future<V> cFuture = executor.submit(new MyCallable(param3));
    // this will block until all calculations are finished:
    a = aFuture.get();
    b = bFuture.get();
    c = cFuture.get();
   // do something with a/b/c, e.g. calc new params.
}

Answer 2

您可以为应用程序创建一个执行器服务，专门用于处理这些计算。池大小可能会有所不同，这取决于您是否要同时运行多个计算：

ExecutorService service = Executors.newFixedThreadPool(3);
Future<Integer> submitA = service.submit(new Callable<Integer>() {
  @Override
  public Integer call() throws Exception {
    return processA();
  }
});
Future<Integer> submitB = service.submit(new Callable<Integer>() {
  @Override
  public Integer call() throws Exception {
    return processB();
  }
});
Future<Integer> submitC = service.submit(new Callable<Integer>() {
  @Override
  public Integer call() throws Exception {
    return processC();
  }
});
int result = submitA.get() + submitB.get() + submitC.get();

在这种情况下，您需要确保每次运行计算时都没有创建线程池，在这种情况中，创建线程池的影响与保存相比将很小，假设通过拆分任务可以减少运行时间。