Java重用FixedThreadPool，同时等待主线程完成一批工作

我对Java多线程相当陌生，我已经找到了一些我正在尝试做的事情。然而，作为java线程的新手，我仍然很难理解这些反应

基本上这就是我得到的：

private final ExecutorService mFixedThreadPool;

public ThreadPool(int threadCount) {
    mFixedThreadPool = Executors.newFixedThreadPool(threadCount);
}

public interface Task {
    void phase1();
    void phase2();
    void phase3();
}

public void executeBatch(List<Runnable> tasks) {
    tasks.forEach(task -> mFixedThreadPool.execute(task::phase1));
    tasks.forEach(task -> mFixedThreadPool.execute(task::phase2));
    tasks.forEach(task -> mFixedThreadPool.execute(task::phase3));
    //only return on the main thread once all the tasks are complete.
    //(Dont destroy threadpool as the "executeBatch" method will be called in a loop)
}

私有最终执行器服务mFixedThreadPool；
公共线程池（int threadCount）{
mFixedThreadPool=Executors.newFixedThreadPool（threadCount）；
}
公共接口任务{
无效相位1（）；
无效相2（）；
无效阶段3（）；
}
public void executeBatch（列出任务）{
tasks.forEach（task->mFixedThreadPool.execute（task:：phase1））；
tasks.forEach（task->mFixedThreadPool.execute（task:：phase2））；
tasks.forEach（task->mFixedThreadPool.execute（task:：phase3））；
//所有任务完成后，只返回主线程。
//（不要销毁线程池，因为“executeBatch”方法将在循环中调用）
}

---

我想暂停、停止或等待调用“executeBatch”的线程，直到该批工作完成。我知道可以使用mFixedThreadPool.shutdown（）执行此操作，然后等待其成功关闭，但是，我希望经常重复使用线程，因此每次关闭都是低效的。

如果您想要的是一个线程池，在上一个线程完成之前不会启动下一个线程，您只需使用一个线程创建一个FixedThreadPool：

ExecutorService threadPool = Executors.newFixedThreadPool(1);

如果您想要的是休眠当前线程，直到池使用shutdown完成。shutdown（）正好用于此类任务，但在shutdown之后，您需要创建一个新的ExecutorService：

threadPool.shutdown();
try {
  threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
} catch (InterruptedException e) {
  ...
}

您可以将ExecutorService封装在ExecutorCompletionService中。这将在完成时通知您，而不关闭执行器，如您所愿。查看一些信息

最后一个选择是使用未来。get（）方法会一直阻塞，直到该线程完成，因此您可以：

ExecutorService threadPool = Executors.newFixedThreadPool(4);
List<Callable<String>> tasks = new ArrayList<>();
List<Future<String>> futures = new ArrayList<>();
List<String> result = new ArrayList<>();
tasks.stream().forEachOrdered(task -> futures.add(threadPool.submit(task)));
for (Future<String> future :futures) {
    try {
        result.add(future.get());
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (ExecutionException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }   
}

ExecutorService线程池=Executors.newFixedThreadPool（4）；
列表任务=新建ArrayList（）；
列表期货=新的ArrayList（）；
列表结果=新建ArrayList（）；
tasks.stream（）.forEachOrdered（任务->期货.add（threadPool.submit（任务））；
for（未来：未来）{
试一试{
result.add（future.get（））；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（执行例外）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}   
}

我想我能给你想要的。

---

您可以控制任务的执行，如果需要，可以取消任务，并在主线程中进行计算。

我不明白。你已经链接到一个答案，它确切地告诉你需要做什么。这里的问题是什么？可能是@Michael的重复我只是更新了一点代码，但基本上我已经阅读了我链接的回复以及我能找到的关于这个特定问题的其他几个回复，我真的不明白Futures集合的意义，也不知道我将如何实现这个答案。就像“myRunnable”任务一样，我是否需要为每个任务都这样做，未来是什么；应该这样做，等等。

myRunnable

是一个，令人惊讶的是。就像您的

任务：：阶段一样。是运行runnable的结果。通过迭代所有未来，您将等待所有提交的任务完成。请阅读这些类和方法的JavaDocs。它们很容易找到。我想我的问题很清楚，我想要一个有n个线程的线程池，我可以将成批的任务排队。当这些任务并行执行时，主线程等待所有任务完成。有点像（inti=0；i