What Is a Daemon Thread and How Does It Differ From a Normal Thread?

Core Concept

Daemon thread is a background service thread that does not prevent JVM shutdown. When all non‑daemon (user) threads have terminated, the JVM exits immediately, terminating any remaining daemon threads.

JVM Exit Determination

JVM exits only after every non‑daemon thread finishes; this is an internal rule, not triggered by System.exit().

Daemon threads are forcibly destroyed at that moment.

Creating Daemon Threads

// manual
Thread t = new Thread(() -> {
    while (true) {
        // background work
    }
});
t.setDaemon(true); // must be before start()
t.start();

// via ThreadFactory
ThreadFactory factory = r -> {
    Thread th = new Thread(r);
    th.setDaemon(true);
    return th;
};
ExecutorService pool = Executors.newCachedThreadPool(factory);

setDaemon(true)

called after start() throws IllegalThreadStateException. In thread‑pool scenarios configure a ThreadFactory to set the flag for all pool threads.

Typical Daemon Use Cases

JVM‑provided garbage‑collection thread.

Heartbeat thread that periodically sends a signal to a registry.

Metrics‑collection thread that reports JVM statistics.

Log‑cleanup thread that deletes expired log files.

Cache‑warm‑up or refresh thread that updates a local cache.

Common Pitfalls

Finally block

Code in a finally block of a daemon thread is not guaranteed to run because the JVM may kill the thread during shutdown.

Thread t = new Thread(() -> {
    try {
        Thread.sleep(5000);
    } finally {
        System.out.println("Resource cleanup"); // may never execute
    }
});
t.setDaemon(true);
t.start();

I/O Operations

Performing I/O (e.g., writing a file) in a daemon thread can leave the file partially written if the JVM exits.

Thread t = new Thread(() -> {
    writeDataToFile(); // risk of corruption
});
t.setDaemon(true);
t.start();

Child‑thread inheritance

Threads created by a daemon thread inherit the daemon status by default.

Thread daemon = new Thread(() -> {
    Thread child = new Thread(() -> {
        // also a daemon
    });
    child.start();
});
daemon.setDaemon(true);
daemon.start();

Comparison of Daemon vs. User Threads

Setting : Daemon – setDaemon(true) before start(); User – default.

JVM exit : Daemon threads do not block JVM exit; user threads block until they finish.

Finally execution : Not guaranteed for daemon threads; guaranteed for user threads.

Child inheritance : Daemon children are daemon; user children are user.

Typical priority : Daemon threads often run at lower priority; user threads use default priority.

Interview‑style Questions

Is the main thread a daemon thread? – No, it is a user thread; the JVM stays alive while main or any user thread it spawns is running.

When does a daemon thread’s finally block execute? – Only if the daemon thread terminates normally or is interrupted; it is not executed when the JVM shuts down because all user threads have finished.

How to use daemon threads in a Spring Boot application? – Spring’s @Scheduled tasks run on user threads. If a custom daemon thread is created for monitoring, you may need a ShutdownHook to perform graceful cleanup because the daemon may be killed on application shutdown.

Key Rules

Daemon threads are suitable for optional background work that can be abandoned when the application ends (e.g., GC, heartbeat, monitoring).

Never rely on daemon threads for critical resource release, data persistence, or I/O.