检查线程是否关闭，并在关闭后执行任务

Question

我正在创建一个固定大小的线程池，包含10个线程，如下所示：

ExecutorService executorService = Executors.newFixedThreadPool(10);

for (int i = 0; i < poolSize; ++i) {
   executorService.execute(factory.get());
}

现在，在生成10个线程之后，每个线程都会执行一个runnable。这里的Runnable由工厂提供。得到（）

现在，我想做一件事，一旦一个线程被关闭，也就是说，它完成了一个任务，它就会再次选择另一个runnable并开始运行它。因此，基本上检查所有10个线程的状态，并在线程关闭时再次执行runnable。

我知道我可以这样做，在其中我可以调用executorService shutdown（）方法，如下所示：

   while (!executorService.isShutdown()) {
        try {
            executorService.execute(factory.get());
        } catch (RejectedExecutionException e) {
            if (!executorService.isShutdown())
                log.warn("task submission rejected");
        }
    }

但在这种方法中，问题是我一直在调用execute函数，这会增加LinkedBlockingQueue，不符合我的目的。

如果我能以某种方式检查线程状态，那将是件好事，因为这样可以避免返回执行器服务获取更多工作的开销。

请建议如何在代码中做到这一点。

Answer 1

如果要连续运行10个线程，为什么要使用线程池？只需自己开始10个线程。

为什么在10个工作线程之上有一个“控制器”线程？让每个线程请求执行下一个任务。

以下假设工厂。get（）是线程安全的。

for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        for (;;) {
            Runnable r = factory.get(); // <-- must be thread-safe
            if (r == null)
                break; // stop thread if no more tasks to execute
            try {
                r.run();
            } catch (Exception e) {
                // log exception here
            }
        }
    }).start();
}

如果需要，将10个线程对象保存在一个数组中。

如果您希望能够在没有工厂的情况下关闭线程。get（）返回null，添加一个volatile boolean，并在循环中检查它。

Answer 2

您可以使用有界执行器。以下是jcip的Brian Goetz的代码

/**
 * BoundedExecutor
 * <p/>
 * Using a Semaphore to throttle task submission
 *
 * @author Brian Goetz and Tim Peierls
 */
public class BoundedExecutor {
    private final Executor exec;
    private final Semaphore semaphore;

    public BoundedExecutor(Executor exec, int bound) {
        this.exec = exec;
        this.semaphore = new Semaphore(bound);
    }

    public void submitTask(final Runnable command)
            throws InterruptedException {
        semaphore.acquire();
        try {
            exec.execute(new Runnable() {
                public void run() {
                    try {
                        command.run();
                    } finally {
                        semaphore.release();
                    }
                }
            });
        } catch (RejectedExecutionException e) {
            semaphore.release();
        }
    }
}

然后只需创建并使用它：

ExecutorService executorService = Executors.newFixedThreadPool(10);
BoundedExecutor boundedExecutor = new BoundedExecutor(executorService,10);

while (!executorService.isShutdown()) {
    try {
        boundedExecutor.submitTask(factory.get());
    } catch (InterruptedException e) {
    }
}       

这样，您将始终有10个线程在运行，新任务只会在旧任务完成后提交，您可以通过关闭执行程序来停止执行。