Перетворення ExecutorService на демон в Java

Я використовую ExecutoreService в Java 1.6, запущений просто

ExecutorService pool = Executors.newFixedThreadPool(THREADS). 

Коли мій основний потік буде закінчений (разом із усіма завданнями, обробленими пулом потоків), цей пул не дозволить моїй програмі зупинитися, поки я явно не покличу

pool.shutdown();

Чи можу я уникнути необхідності викликати це, як-небудь перетворивши управління внутрішнім потоком, що використовується цим пулом, у потік deamon? Або мені чогось тут не вистачає.

Ймовірно, найпростіше і бажане рішення - у відповіді Marco13, тому не обманюйте себе різницею голосів (моя відповідь на кілька років старша) або знаком прийняття (це просто означає, що моє рішення було підходящим для обставин OP, а не того, що найкраще).

Ви можете використовувати ThreadFactoryдля встановлення потоків усередині Executor для демонів. Це вплине на службу виконавця таким чином, що вона також стане потоком демона, тому вона (і оброблені нею потоки) зупиниться, якщо не буде іншого потоку, що не є демоном. Ось простий приклад:

ExecutorService exec = Executors.newFixedThreadPool(4,
        new ThreadFactory() {
            public Thread newThread(Runnable r) {
                Thread t = Executors.defaultThreadFactory().newThread(r);
                t.setDaemon(true);
                return t;
            }
        });

exec.execute(YourTaskNowWillBeDaemon);

Але якщо ви хочете отримати виконавця, який дозволить завершити своє завдання, і в той же час автоматично викличе свій shutdown()метод, коли заявка буде завершена, можливо, ви захочете обернути свого виконавця методом Гуави MoreExecutors.getExitingExecutorService .

ExecutorService exec = MoreExecutors.getExitingExecutorService(
        (ThreadPoolExecutor) Executors.newFixedThreadPool(4), 
        100_000, TimeUnit.DAYS//period after which executor will be automatically closed
                             //I assume that 100_000 days is enough to simulate infinity
);
//exec.execute(YourTask);
exec.execute(() -> {
    for (int i = 0; i < 3; i++) {
        System.out.println("daemon");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
});

Вже є вбудована функціональність для створення, ExecutorServiceяка завершує всі потоки після певного періоду бездіяльності: Ви можете створити ThreadPoolExecutor, передати йому потрібну інформацію про час, а потім зателефонувати allowCoreThreadTimeout(true)до цієї служби виконавця:

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

EDIT З посиланням на зауваження в коментарях: Зверніть увагу, що виконавець цього пулу потоків не вимкнеться автоматично при виході програми. Виконавець продовжить роботу після виходу програми, але не довше ніж keepAliveTime. Якщо, залежно від точних вимог програми, значення keepAliveTimeмає бути більше кількох секунд, рішення у відповіді Pshemo може бути більш доречним: Коли потоки встановлені як демонові потоки, вони закінчаться негайно, коли програма закриється .

Я б використав клас 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
);

або скористайтеся ним, щоб легко запустити демонову нитку з 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);
}

Ви можете використовувати ThreadFactoryBuilder від Guava. Я не хотів додавати залежність, і я хотів функціональність від 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;
    }
}

Якщо у вас є відомий список завдань, вам зовсім не потрібні потоки демонів. Ви можете просто викликати 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); 
}