问题描述

我正在Java 1.6中使用一个ExecutoreService，简单地开始

ExecutorService pool = Executors.newFixedThreadPool(THREADS). 

当我的主线程完成(以及由线程池处理的所有任务)时，此池将阻止我的程序关闭，直到我明确地调用

pool.shutdown(); 

我可以避免通过某种方式将这个池使用的内部线程管理转换成deamon线程来调用吗？或者我在这里遗漏了一些东西。

最佳解决方案

大概最简单和最优的解决方案是在Marco13’s answer中，所以不要被投票差异(我的回答是几年前)或接受标记(这意味着我的解决方案适合于OP情况不是最好的)。

您可以使用ThreadFactory将Executor中的线程设置为守护程序。这将影响执行器服务，它也将成为守护进程线程，因此如果没有其他non-daemon线程，它(以及由其处理的线程)将停止。这是一个简单的例子：

1.   ExecutorService exec = Executors.newFixedThreadPool( 4,
2.   new ThreadFactory() {
3.   public Thread newThread(Runnable r) {
4.   Thread t = Executors.defaultThreadFactory().newThread(r);
5.   t.setDaemon( true);
6.   return t;
7.   }
8.   });
9.    
10.   exec.execute(YourTaskNowWillBeDaemon);

但是如果你想获得执行器，让它的任务完成，同时在应用程序完成后会自动调用它的shutdown()方法，你可能希望用Guava’s MoreExecutors.getExitingExecutorService来包装你的执行器。

1.   ExecutorService exec = MoreExecutors.getExitingExecutorService(
2.   (ThreadPoolExecutor) Executors.newFixedThreadPool( 4),
3.   100_000, TimeUnit.DAYS//period after which executor will be automatically closed
4.   //I assume that 100_000 days is enough to simulate infinity
5.   );
6.   //exec.execute(YourTask);
7.   exec.execute(() -> {
8.   for (int i = 0; i < 3; i++) {
9.   System. out.println(“daemon”);
10.   try {
11.   TimeUnit.SECONDS.sleep( 1);
12.   } catch (Exception e) {
13.   e.printStackTrace();
14.   }
15.   }
16.   });

次佳解决方案

已经有一个内置功能用于创建一个ExecutorService，在一段时间不活动后终止所有线程：您可以创建一个ThreadPoolExecutor，传递所需的时序信息，然后在此执行器服务上调用allowCoreThreadTimeout(true)：

1.   /**
2.   * Creates an executor service with a fixed pool size, that will time
3.   * out after a certain period of inactivity.
4.   *
5.   * @param poolSize The core- and maximum pool size
6.   * @param keepAliveTime The keep alive time
7.   * @param timeUnit The time unit
8.   * @return The executor service
9.   */
10.   public static ExecutorService createFixedTimeoutExecutorService(
11.   int poolSize, long keepAliveTime, TimeUnit timeUnit)
12.   {
13.   ThreadPoolExecutor e =
14.   new ThreadPoolExecutor(poolSize, poolSize,
15.   keepAliveTime, timeUnit, new LinkedBlockingQueue<Runnable>());
16.   e.allowCoreThreadTimeOut( true);
17.   return e;
18.   }

EDIT Referring to the remarks in the comments: Note that this thread pool executor will not automatically shut down when the application exits. The executor will continue to run after the application exits, but no longer than the keepAliveTime. If, depending on the precise application requirements, the keepAliveTime has to be longer than a few seconds, the solution in the answer by Pshemo may be more appropriate: When the threads are set to be daemon threads, then they will end immediately when the application exits.

第三种解决方案

我会使用Guava的ThreadFactoryBuilder类。

ExecutorService threadPool = Executors.newFixedThreadPool(THREADS, new ThreadFactoryBuilder().setDaemon(true).build()); 

如果你还没有使用Guava，我会去一个ThreadFactory子类，如Pshemo’s answer顶部所述

第四种方案

是。

您只需创建自己的ThreadFactory类，即创建守护进程线程而不是常规线程。

参考文献

• Turning an ExecutorService to daemon in Java