Java 我们如何知道threadPoolExecutor已完成执行

我有一个向MQ发送消息的父线程，它为侦听MQ并将消息写入输出文件的工作线程管理ThreadPoolExecutor。我管理一个5号的线程池。所以当我运行我的程序时，我有5个带有消息的文件。在这里之前一切都很好。我现在需要在父线程中合并这5个文件

如何知道ThreadPoolExecutor已完成处理，以便开始合并文件

public class ParentThread {
    private MessageSender messageSender;
    private MessageReciever messageReciever;
    private Queue jmsQueue;
    private Queue jmsReplyQueue;
    ExecutorService exec = Executors.newFixedThreadPool(5);

    public void sendMessages() {
        System.out.println("Sending");
        File xmlFile = new File("c:/filename.txt");
        List<String> lines = null;
        try {
            lines = FileUtils.readLines(xmlFile, null);
        } catch (IOException e) {
            e.printStackTrace();
        }
        for (String line : lines){
            messageSender.sendMessage(line, this.jmsQueue, this.jmsReplyQueue);
        }
        int count = 0;
        while (count < 5) {
            messageSender.sendMessage("STOP", this.jmsQueue, this.jmsReplyQueue);
            count++;
        }

    }

    public void listenMessages() {
        long finishDate = new Date().getTime();
        for (int i = 0; i < 5; i++) {
            Worker worker = new Worker(i, this.messageReciever, this.jmsReplyQueue);
            exec.execute(worker);
        }
        exec.shutdown();

        if(exec.isTerminated()){ //PROBLEM is HERE. Control Never gets here.
            long currenttime = new Date().getTime() - finishDate;
            System.out.println("time taken: "+currenttime);
            mergeFiles();
        }
    }
}

我如何知道线程池何时完成处理，以便我可以执行其他清理工作

谢谢诸如此类的东西：

    exec.shutdown();

    // waiting for executors to finish their jobs
    while (!exec.awaitTermination(50, TimeUnit.MILLISECONDS));

    // perform clean up work

---

如果Worker类实现了Callable而不是Runnable，那么您将能够通过使用Future对象查看线程是否返回了某些结果（例如，布尔值，它将告诉您线程是否已完成执行）来查看线程何时完成

看看下面的“8.期货和可赎回债券”网站，它正好满足了您的需要：

---

编辑：因此，在所有的未来指示各自可调用的执行已完成后，可以安全地假设您的执行器已完成执行，并且可以手动关闭/终止。

您可以使用线程来监视ThreadPoolExecutor，就像这样

import java.util.concurrent.ThreadPoolExecutor;

public class MyMonitorThread implements Runnable {
     private ThreadPoolExecutor executor;

        private int seconds;

        private boolean run=true;

        public MyMonitorThread(ThreadPoolExecutor executor, int delay)
        {
            this.executor = executor;
            this.seconds=delay;
        }

        public void shutdown(){
            this.run=false;
        }

        @Override
        public void run()
        {
            while(run){
                    System.out.println(
                        String.format("[monitor] [%d/%d] Active: %d, Completed: %d, Task: %d, isShutdown: %s, isTerminated: %s",
                            this.executor.getPoolSize(),
                            this.executor.getCorePoolSize(),
                            this.executor.getActiveCount(),
                            this.executor.getCompletedTaskCount(),
                            this.executor.getTaskCount(),
                            this.executor.isShutdown(),
                            this.executor.isTerminated()));
                    try {
                        Thread.sleep(seconds*1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            }

        }

}

加

MyMonitorThread monitor = new MyMonitorThread(executorPool, 3);
            Thread monitorThread = new Thread(monitor);
            monitorThread.start(); 

到ThreadPoolExecutor所在的类

---

它将每隔3秒显示threadpoolexecutors的状态

谢谢SilverHaze。正是我想要的。

MyMonitorThread monitor = new MyMonitorThread(executorPool, 3);
            Thread monitorThread = new Thread(monitor);
            monitorThread.start();