Daemon Threads in Java
Not every thread in a Java application represents work that must keep the application alive. Some threads exist only to perform background or supporting tasks while the main application is running. Java provides daemon threads for this purpose.
A daemon thread is a background thread that does not prevent the JVM from shutting down. When all remaining live threads are daemon threads, the JVM can terminate.
Important: A daemon thread is not simply a "lower-priority" thread. Its defining characteristic is that daemon threads do not keep the JVM alive when no non-daemon threads remain.
What Is a Daemon Thread?
A daemon thread is a thread intended to provide background services or supporting work for other threads.
Typical examples can include background monitoring, housekeeping, cache maintenance, or other support operations that do not need to keep the application running by themselves.
Thread backgroundTask = new Thread(() -> {
while (true) {
System.out.println(
"Background task running"
);
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
});
backgroundTask.setDaemon(true);
backgroundTask.start();
The thread is configured as a daemon before it is started. If the JVM eventually has no live non-daemon threads, the JVM can exit even if this daemon thread is still running.
Non-Daemon vs Daemon Threads
The most important difference is whether the thread can keep the JVM alive.
| Non-Daemon Thread | Daemon Thread |
|---|---|
| Can keep the JVM alive while it is running. | Does not keep the JVM alive when no non-daemon threads remain. |
| Typically performs work that must complete or be explicitly managed. | Typically performs background or supporting work. |
| Normally used for application-critical execution. | Normally used for supporting background activities. |
| JVM waits for live non-daemon threads before normal shutdown. | JVM does not wait for daemon threads merely because they are still alive. |
Creating a Daemon Thread
Use setDaemon(true) before calling start().
Thread worker = new Thread(() -> {
System.out.println("Daemon task");
});
worker.setDaemon(true);
worker.start();
The order is important. Once a Thread has been started, attempting to change its daemon status results in IllegalThreadStateException.
Rule: Configure daemon status before calling start().
Checking Whether a Thread Is a Daemon
The isDaemon() method tells you whether a Thread is configured as a daemon thread.
Thread worker = new Thread(() -> {
System.out.println("Background work");
});
worker.setDaemon(true);
System.out.println(
"Is daemon: " + worker.isDaemon()
);
The output will be:
Is daemon: true
Default Daemon Status
A newly created thread normally inherits the daemon status of the thread that creates it.
Thread parent = Thread.currentThread();
System.out.println(
"Parent daemon: " + parent.isDaemon()
);
Thread child = new Thread(() -> {
System.out.println(
"Child daemon: "
+ Thread.currentThread().isDaemon()
);
});
If the parent is a non-daemon thread, a newly created child thread will normally also be non-daemon unless its status is explicitly changed before starting.
Daemon Threads and JVM Shutdown
Consider an application with one normal thread and one daemon thread.
Thread daemon = new Thread(() -> {
while (true) {
System.out.println(
"Daemon is working"
);
try {
Thread.sleep(500);
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
});
daemon.setDaemon(true);
daemon.start();
System.out.println(
"Main thread is finishing"
);
When the main thread finishes, if no other non-daemon threads remain, the JVM is allowed to terminate. It does not wait indefinitely for the daemon thread's infinite loop to finish.
Remember: The JVM's shutdown behavior is based on the presence of live non-daemon threads, not on whether daemon threads are still running.
Daemon Threads Do Not Get Special Scheduling Priority
A daemon thread is not automatically a low-priority thread. Daemon status and thread priority are separate properties.
Thread worker = new Thread(() -> {
System.out.println("Daemon worker");
});
worker.setDaemon(true);
worker.setPriority(Thread.MAX_PRIORITY);
worker.start();
This is technically possible. The thread is still a daemon even though it has a high priority.
Therefore:
| Property | Controls |
|---|---|
| Daemon status | Whether the thread can keep the JVM alive. |
| Priority | A scheduling preference that does not guarantee execution order. |
Daemon Threads Are Not Automatically Safer
Calling a thread "daemon" does not make its code automatically thread-safe, cancellable, or harmless. A daemon thread can still access shared mutable state, acquire locks, perform I/O, and introduce synchronization problems.
The daemon flag only changes the JVM's shutdown behavior.
Industry insight: Do not use daemon status as a substitute for proper lifecycle management. If a task must finish reliably, save important data, release an external resource correctly, or complete a transaction, it should not depend on daemon-thread shutdown semantics.
When Should You Use Daemon Threads?
Daemon threads are appropriate for work that supports the application but does not independently justify keeping the JVM alive.
- Background monitoring tasks.
- Periodic housekeeping work.
- Non-critical maintenance operations.
- Background support activities whose abrupt termination is acceptable.
The key question is not "Is this task running in the background?" Instead, ask: "Can this task safely disappear when the JVM has no non-daemon work left?"
When Should You Avoid Daemon Threads?
Do not rely on daemon threads for work that must complete successfully.
- Saving critical business data.
- Completing financial transactions.
- Writing essential records to persistent storage.
- Completing important external API operations.
- Performing mandatory cleanup that the application must guarantee.
If the application must guarantee completion, the task needs explicit lifecycle management rather than depending on the JVM to keep a daemon alive.
Example: Monitoring Thread
public class DaemonDemo {
public static void main(String[] args) {
Thread monitor = new Thread(() -> {
while (true) {
System.out.println(
"Monitoring application..."
);
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
});
monitor.setName("System-Monitor");
monitor.setDaemon(true);
monitor.start();
System.out.println(
"Main application work completed"
);
}
}
The monitoring thread provides background support. Once the main application and all other non-daemon threads finish, the JVM can shut down even though the monitor would otherwise continue running.
Daemon Thread and Resource Cleanup
A common mistake is assuming that a daemon thread will always get an opportunity to perform cleanup before JVM termination.
Thread daemon = new Thread(() -> {
try {
System.out.println(
"Daemon started"
);
while (true) {
Thread.sleep(1000);
}
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.out.println(
"Cleanup logic"
);
}
});
daemon.setDaemon(true);
daemon.start();
You should not design critical cleanup around the assumption that the daemon thread will always receive an interruption or a final execution opportunity when the JVM exits.
Best mental model: A daemon thread is allowed to disappear when the JVM no longer has non-daemon work. Design accordingly.
Common Beginner Mistakes
- Thinking daemon means low priority.
- Calling setDaemon(true) after start().
- Using daemon threads for critical business operations.
- Assuming daemon threads are automatically interrupted during JVM shutdown.
- Assuming daemon status makes a thread thread-safe.
- Relying on daemon threads for guaranteed resource cleanup.
Best Practices
- Use daemon threads only when abrupt termination is acceptable.
- Set daemon status before starting the thread.
- Use descriptive names for long-running background threads.
- Do not place critical business operations exclusively inside daemon threads.
- Use explicit shutdown and lifecycle management when background work must be completed safely.
- Remember that daemon status and thread priority solve completely different problems.
Interview Insights
Question: What is a daemon thread in Java?
A daemon thread is a background thread that does not prevent the JVM from terminating when no live non-daemon threads remain.
Question: How do you create a daemon thread?
Call setDaemon(true) on the Thread before calling start().
Question: Can setDaemon() be called after start()?
No. Attempting to change the daemon status after the thread has started results in IllegalThreadStateException.
Question: Does the JVM wait for daemon threads during shutdown?
No. Once no live non-daemon threads remain, the JVM can terminate without waiting for daemon threads to complete.
Question: Are daemon threads lower priority than normal threads?
No. Daemon status and priority are independent properties. A daemon thread can have any valid thread priority.
Quick Revision
| Concept | Key Point |
|---|---|
| Daemon Thread | A background thread that does not keep the JVM alive. |
| setDaemon(true) | Marks a thread as daemon before it is started. |
| isDaemon() | Checks whether a thread is a daemon. |
| JVM Shutdown | The JVM can terminate when no live non-daemon threads remain. |
| Priority | Independent from daemon status. |
| Critical work | Should not depend on a daemon thread for guaranteed completion. |
| Cleanup | Do not assume daemon threads will reliably complete cleanup during JVM termination. |
Daemon threads are best understood as supporting background workers whose continued existence is not required to keep the application alive. The daemon flag does not make a thread faster, safer, or lower priority—it simply changes how the JVM treats that thread during shutdown. With daemon behavior understood, the next chapter moves into one of the most important areas of multithreading: Synchronization, where we learn how multiple threads can safely coordinate access to shared data.