Превращение ExecutorService в демон в Java

Я бы использовал класс Guava ThreadFactoryBuilder.

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

Если вы еще не используете Guava, я бы выбрал подкласс ThreadFactory, как описано в верхней части ответа Pshemo

Если вы хотите использовать его только в одном месте, вы можете встроить реализацию java.util.concurrent.ThreadFactory, например для пула с 4 потоками вы должны написать (пример показан как лямбда для Java 1.8 или новее):

ExecutorService pool = Executors.newFixedThreadPool(4,
        (Runnable r) -> {
            Thread t = new Thread(r);
            t.setDaemon(true);
            return t;
        }
);

Но обычно я хочу, чтобы все мои фабрики Thread создавали потоки демонов, поэтому я добавляю служебный класс следующим образом:

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;
    }
}

Это позволяет мне легко передавать DaemonThreadFactory.instance ExecutorService, например

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

или используйте его, чтобы легко запустить поток daemon из Runnable, например

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

да.

Вам просто нужно создать свой собственный ThreadFactory класс, который создает потоки демонов, а не обычные потоки.

Это решение похоже на решение @ Marco13, но вместо создания нашего собственного ThreadPoolExecutor мы можем изменить то, которое возвращает Executors#newFixedThreadPool(int nThreads). Вот как:

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

Вы можете использовать Guava ThreadFactoryBuilder. Я не хотел добавлять зависимость, и мне нужна была функциональность от Executors.DefaultThreadFactory, поэтому я использовал композицию:

class DaemonThreadFactory implements ThreadFactory {
    final ThreadFactory delegate;

    DaemonThreadFactory() {
        this(Executors.defaultThreadFactory());
    }

    DaemonThreadFactory(ThreadFactory delegate) {
        this.delegate = delegate;
    }

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

Это не точно ответ на поставленный вопрос, но может оказаться полезным:

Как отмечали другие, вы можете создать DaemonThreadFactory, либо встроенный, либо как служебный класс.

Создав подкласс Runnable, вы можете получить результирующий DaemonThread из вышеуказанного Factory для выполнения всего исполняемого модуля в отдельно созданном не-демоническом потоке. При нормальных обстоятельствах этот поток, не являющийся демоном, будет завершен, даже если поток демона, используемый в Executor, предназначен для закрытия.

Вот небольшой пример:

import static java.util.concurrent.TimeUnit.*;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.*;

public class ScheduleStackOverflow {

    private static final DateTimeFormatter DTF_HH_MM_SS = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");

    private static final class ThreadRunnable implements Runnable {

        private final Runnable runnable;

        public ThreadRunnable(final Runnable runnable) {
            this.runnable = runnable;
        }
        @Override
        public void run() {
            final Thread delegateThread = new Thread(this.runnable);
            /**/         delegateThread.setDaemon(false); // TODO Try changing this to "true"
            /**/         delegateThread.start();
        }
    }

    public static void main(final String[] args) throws InterruptedException {

        final     ThreadFactory daemonThreadFactory = (daemonRunnable) -> {
            final Thread        daemon = new Thread   (daemonRunnable);
            /**/                daemon.setDaemon(true);
            return              daemon;
        };

        final Runnable runnable = new ThreadRunnable(() -> {
            System.out.println(DTF_HH_MM_SS.format(LocalTime.now()) + " daemon=" + Thread.currentThread().isDaemon() + " Scheduling...");

            sleep(5, SECONDS);

            System.out.println(DTF_HH_MM_SS.format(LocalTime.now()) + " daemon=" + Thread.currentThread().isDaemon() + " Schedule done.");
        });

        Executors
        .newSingleThreadScheduledExecutor(daemonThreadFactory)
        .scheduleAtFixedRate(runnable, 0, Duration.ofSeconds(10).toNanos(), NANOSECONDS);

        sleep(12, SECONDS);

        System.out.println(DTF_HH_MM_SS.format(LocalTime.now()) + " Main CLOSED!");
    }

    private static void sleep(final long timeout, final TimeUnit timeunit) {
        try {timeunit.sleep(timeout);} catch (InterruptedException e) {}
    }
}

Если у вас есть известный список задач, вам вообще не нужны потоки демонов. Вы можете просто вызвать shutdown () для ExecutorService после отправки всех ваших задач.

Когда ваш основной поток завершен, используйте метод awaitTermination (), чтобы дать время для выполнения отправленных задач. В настоящее время отправленные задачи будут выполнены, а пул потоков завершит свой управляющий поток после их завершения.

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); 
}