Что такое поток-демон?

Потоки-демоны (Daemon Threads) в Java

Поток-демон — это специальный тип потока, который автоматически завершается, когда завершаются все остальные (не-демонские) потоки. Это полезный механизм для фоновых задач, но его нужно использовать осторожно.

Определение

Поток-демон — это поток, который работает в фоне и не препятствует завершению программы. JVM будет ждать завершения всех обычных потоков, но не будет ждать демонских потоков.

Thread daemonThread = new Thread(() -> {
    while (true) {
        System.out.println("I am a daemon");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
    }
});

// Помечаем как демон
daemonThread.setDaemon(true);
daemonThread.start();

// Если демон не помечен как daemon, JVM будет ждать его
// Если помечен — JVM завершится даже если демон ещё работает

Жизненный цикл демонского потока

Основной поток           Демонский поток
    |                         |
    | start daemon thread     |
    |========================>| (демон работает)
    |                         |
    | выполняет работу        | (фоновая работа)
    |                         |
    | завершается             | (демон прерывается!)
    | (JVM тоже завершается)  |
    |                         | (нет, не ждёт)
   END                       END

Пример: обычный поток

public class NormalThreadExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("Working: " + i);
                try { Thread.sleep(500); } catch (InterruptedException e) {}
            }
        });
        
        // НЕ помечаем как daemon
        // thread.setDaemon(true);
        thread.start();
        
        System.out.println("Main thread finished");
    }
}

// Вывод:
// Main thread finished
// Working: 0
// Working: 1
// ... (main будет ждать)
// Working: 9

Пример: демонский поток

public class DaemonThreadExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("Working: " + i);
                try { Thread.sleep(500); } catch (InterruptedException e) {}
            }
        });
        
        // Помечаем как daemon
        thread.setDaemon(true);
        thread.start();
        
        System.out.println("Main thread finished");
    }
}

// Вывод:
// Main thread finished
// Working: 0
// Working: 1
// Working: 2
// (программа завершается, демонский поток прерывается)

Проверка статуса потока

Thread thread = new Thread(() -> {});

// По умолчанию потоки НЕ являются демонами
System.out.println(thread.isDaemon());  // false

thread.setDaemon(true);
System.out.println(thread.isDaemon());  // true

thread.start();

// ВАЖНО: setDaemon() должен вызваться ДО start()
thread.setDaemon(true);  // IllegalThreadStateException!

Где используются daemon потоки

1. Сборщик мусора (Garbage Collector)

// Внутри JVM эти потоки — daemon потоки
// Когда все обычные потоки завершаются, GC тоже останавливается

2. Потоки пула ExecutorService

ExecutorService executor = Executors.newFixedThreadPool(4);
// По умолчанию потоки в пуле НЕ демоны
// Нужно создавать с ThreadFactory если хочешь daemon потоки

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

3. Фоновые мониторы и watchdog потоки

public class ApplicationMonitor {
    public static void setupDaemonMonitor() {
        Thread monitor = new Thread(() -> {
            while (true) {
                try {
                    // Проверяем здоровье приложения
                    checkHealth();
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
        
        monitor.setDaemon(true);  // Не препятствует завершению
        monitor.setName("ApplicationMonitor");
        monitor.start();
    }
    
    private static void checkHealth() {
        System.out.println("System health check");
    }
}

4. Логирование в фоне

public class AsyncLogger {
    private static final Queue<String> logQueue = new ConcurrentLinkedQueue<>();
    
    static {
        Thread logWriterThread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                String log = logQueue.poll();
                if (log != null) {
                    writeToFile(log);
                }
                try { Thread.sleep(100); } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        
        logWriterThread.setDaemon(true);
        logWriterThread.setName("AsyncLogger");
        logWriterThread.start();
    }
    
    public static void log(String message) {
        logQueue.offer(message);
    }
    
    private static void writeToFile(String log) {
        // Записываем в файл
    }
}

ВАЖНО: Потерянные данные

Очень опасно использовать daemon потоки для критичных задач:

// ПЛОХО! Данные могут быть потеряны
Thread saveThread = new Thread(() -> {
    while (true) {
        try {
            // Сохраняем важные данные
            saveData();
            Thread.sleep(10000);
        } catch (InterruptedException e) {}
    }
});
saveThread.setDaemon(true);  // ОПАСНО!
saveThread.start();

// Если JVM завершится ДО сохранения, данные потеряются!

Правильный способ:

// ХОРОШО! Используем shutdown hook
Thread saveThread = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            saveData();
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
});

saveThread.setDaemon(false);  // НЕ daemon
saveThread.start();

// Гарантируем сохранение перед выходом
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    try {
        saveThread.join();  // Ждём завершения
    } catch (InterruptedException e) {}
}));

Таблица: Обычные потоки vs Daemon потоки

Аспект              Обычный поток      Daemon поток
-------------------------------------------------
Препятствует выходу Да                 Нет
Использование       Основная работа     Фоновые задачи
Ответственность     Высокая             Низкая
Потеря данных       Маловероятна        Возможна
Пример              Основной поток      GC, мониторы

Лучшие практики

1. Используй daemon потоки только для фоновых задач, которые не критичны
2. Для критичных задач используй обычные потоки с явным управлением жизненным циклом
3. Используй ExecutorService с shutdown() вместо ручных потоков
4. Помни про shutdown hooks для важных операций при выходе
5. Документируй в коде, почему поток помечен как daemon

// Хорошо документировано
Thread monitorThread = new Thread(this::monitor);
monitorThread.setDaemon(true);  // Фоновый мониторинг, не критичен
monitorThread.start();

Daemon потоки — это мощный инструмент, но использовать его нужно осмысленно.