Convertir un ExecutorService a daemon en Java

Ya hay una funcionalidad incorporada para crear un ExecutorService que termina todos los subprocesos después de un cierto período de inactividad: Puede crear un ThreadPoolExecutor, pasarle la información de tiempo deseada y luego llamar a allowCoreThreadTimeout(true) en este servicio ejecutor:

/**
 * Creates an executor service with a fixed pool size, that will time 
 * out after a certain period of inactivity.
 * 
 * @param poolSize The core- and maximum pool size
 * @param keepAliveTime The keep alive time
 * @param timeUnit The time unit
 * @return The executor service
 */
public static ExecutorService createFixedTimeoutExecutorService(
    int poolSize, long keepAliveTime, TimeUnit timeUnit)
{
    ThreadPoolExecutor e = 
        new ThreadPoolExecutor(poolSize, poolSize,
            keepAliveTime, timeUnit, new LinkedBlockingQueue<Runnable>());
    e.allowCoreThreadTimeOut(true);
    return e;
}

EDITAR Haciendo referencia a las observaciones en los comentarios: Tenga en cuenta que este ejecutor del grupo de subprocesos no se apagará automáticamente cuando se cierre la aplicación. El ejecutor continuará ejecutándose después de que la aplicación salga, pero no más de el keepAliveTime. Si, dependiendo de los requisitos precisos de la aplicación, el keepAliveTime tiene que ser más largo que unos pocos segundos, la solución en la respuesta de Pshemo puede ser más apropiada: Cuando los subprocesos se establecen como subprocesos daemon, entonces terminarán inmediatamente cuando la aplicación salga.

Usaría la clase ThreadFactoryBuilder de Guava.

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

Si aún no estás usando Guayaba, iría con una subclase ThreadFactory como se describe en la parte superior de La respuesta de Pshemo

Sí.

Simplemente necesita crear su propia clase ThreadFactory que cree subprocesos daemon en lugar de subprocesos regulares.

Esta solución es similar a la de @Marco13, pero en lugar de crear nuestra propia ThreadPoolExecutor, podemos modificar la que devuelve Executors#newFixedThreadPool(int nThreads). He aquí cómo:

ExecutorService ex = Executors.newFixedThreadPool(nThreads);
 if(ex instanceof ThreadPoolExecutor){
    ThreadPoolExecutor tp = (ThreadPoolExecutor) ex;
    tp.setKeepAliveTime(time, timeUnit);
    tp.allowCoreThreadTimeOut(true);
}

Normalmente quiero que mis subprocesos se ejecuten como subprocesos demonio, así que agregué una clase de utilidad de la siguiente manera:

import java.util.concurrent.ThreadFactory;

public class DaemonThreadFactory implements ThreadFactory {

    public final static ThreadFactory instance = 
                    new DaemonThreadFactory();

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setDaemon(true);
        return t;
    }
}

Que me permite pasar fácilmente DaemonThreadFactory.instance al ExecutorService, por ejemplo,

ExecutorService exec = Executors.newFixedThreadPool(
    4, DaemonThreadFactory.instance
);

O úselo para iniciar fácilmente un hilo daemon desde un Runnable, por ejemplo,

DaemonThreadFactory.instance.newThread(
    () -> { doSomething(); }
).start();

Si tiene una lista conocida de tareas, no necesita hilos de demonio en absoluto. Simplemente puede llamar a shutdown () en el ExecutorService después de enviar todas sus tareas.

Cuando se complete el subproceso principal, utilice el método awaitTermination() para dar tiempo a que se completen las tareas enviadas.Las tareas enviadas actualmente se ejecutarán, y el grupo de subprocesos terminará su subproceso de control una vez que se hayan completado.

for (Runnable task : tasks) {
  threadPool.submit(task);
}
threadPool.shutdown();
/*... do other stuff ...*/
//All done, ready to exit
while (!threadPool.isTerminated()) {
  //this can throw InterruptedException, you'll need to decide how to deal with that.
  threadPool.awaitTermination(1,TimeUnit.SECOND); 
}