Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Daemon Threads in Java — what they are, how they differ from user threads, JVM shutdown behavior, practical use cases like GC and auto-save, and common pitfalls.
What is a Daemon Thread?
A daemon thread is a low-priority background thread that provides services to user threads. The key characteristic: the JVM exits when only daemon threads remain alive.
Think of daemon threads as background services:
- They support the main work (user threads)
- They don't prevent the program from exiting
- They're abruptly terminated when the JVM shuts down
User Threads vs Daemon Threads
┌──────────────────────────────────────────────────────┐
│ JVM │
│ │
│ User Threads (keep JVM alive): │
│ ├── main thread │
│ ├── your worker threads │
│ └── thread pool threads │
│ │
│ Daemon Threads (don't keep JVM alive): │
│ ├── Garbage Collector │
│ ├── Finalizer thread │
│ ├── Signal dispatcher │
│ └── your background service threads │
│ │
│ JVM exits when ALL user threads finish │
│ (daemon threads are killed immediately) │
└──────────────────────────────────────────────────────┘
| Feature | User Thread | Daemon Thread |
|---|---|---|
| JVM waits for it? | YES | NO |
| Purpose | Main application work | Background services |
| Shutdown | Runs to completion | Abruptly killed |
| Default | All new threads | Must explicitly set |
| Examples | main, workers | GC, auto-save, logging |
Creating Daemon Threads
Example
public class DaemonBasic {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Daemon Thread Demo ===\n");
// Create a daemon thread
Thread daemon = new Thread(() -> {
int tick = 0;
while (true) { // Infinite loop — but that's OK for daemons!
tick++;
System.out.println(" [Daemon] Background tick: " + tick);
try { Thread.sleep(500); } catch (InterruptedException e) { return; }
}
}, "MyDaemon");
daemon.setDaemon(true); // MUST set BEFORE start()!
daemon.start();
System.out.println("isDaemon: " + daemon.isDaemon());
System.out.println("Main thread is daemon: " + Thread.currentThread().isDaemon());
// Main thread does some work
System.out.println("\n[Main] Working for 2 seconds...");
Thread.sleep(2000);
System.out.println("[Main] Done! Exiting...");
// When main exits, JVM kills the daemon thread!
// No cleanup, no graceful shutdown for daemon.
}
}
Output:
| isDaemon | true |
| Main thread is daemon | false |
| [Daemon] Background tick | 1 |
| [Daemon] Background tick | 2 |
| [Daemon] Background tick | 3 |
| [Daemon] Background tick | 4 |
Notice: The daemon was in an infinite loop, but the program still exits when main finishes!
Daemon vs Non-Daemon Comparison
Example
public class DaemonComparison {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Daemon vs Non-Daemon ===\n");
// Non-daemon (user) thread — JVM waits for it
Thread userThread = new Thread(() -> {
for (int i = 1; i <= 3; i++) {
System.out.println(" [User Thread] Step " + i);
try { Thread.sleep(600); } catch (InterruptedException e) { return; }
}
System.out.println(" [User Thread] Finished!");
}, "UserThread");
// Daemon thread — JVM does NOT wait
Thread daemonThread = new Thread(() -> {
for (int i = 1; i <= 10; i++) {
System.out.println(" [Daemon] Step " + i);
try { Thread.sleep(400); } catch (InterruptedException e) { return; }
}
System.out.println(" [Daemon] Finished!"); // Likely won't print!
}, "DaemonThread");
daemonThread.setDaemon(true);
userThread.start();
daemonThread.start();
System.out.println("[Main] Both started. Main exiting immediately.\n");
// Main exits, but JVM stays alive for userThread
// When userThread finishes, daemon is killed
}
}
Output:
Example
[Main] Both started. Main exiting immediately.
[Daemon] Step 1
[User Thread] Step 1
[Daemon] Step 2
[User Thread] Step 2
[Daemon] Step 3
[Daemon] Step 4
[User Thread] Step 3
[User Thread] Finished!
The daemon only got to step 4-5 before the JVM shut down (after user thread finished).
Real-World Use Case: Auto-Save Service
Example
import java.util.*;
public class AutoSaveDemo {
private static List<String> document = new ArrayList<>();
private static int lastSavedVersion = 0;
private static int currentVersion = 0;
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Auto-Save Service (Daemon) ===\n");
// Auto-save daemon — saves every 2 seconds if changes exist
Thread autoSave = new Thread(() -> {
while (true) {
try {
Thread.sleep(2000);
if (currentVersion > lastSavedVersion) {
save();
}
} catch (InterruptedException e) {
return;
}
}
}, "AutoSave");
autoSave.setDaemon(true);
autoSave.start();
System.out.println("Auto-save daemon started (saves every 2s if changes)\n");
// Simulate user editing
edit("Hello World");
Thread.sleep(500);
edit("Adding second paragraph");
Thread.sleep(500);
edit("Fixing typos");
Thread.sleep(2500); // Wait for auto-save to trigger
edit("Final changes");
Thread.sleep(500);
// Manual save before exit
save();
System.out.println("\n[User] Closing document. Goodbye!");
// Daemon thread dies when main exits
}
static void edit(String content) {
document.add(content);
currentVersion++;
System.out.println("[Edit] Added: \"" + content + "\" (v" + currentVersion + ")");
}
static synchronized void save() {
if (currentVersion > lastSavedVersion) {
lastSavedVersion = currentVersion;
System.out.println(" 💾 [AutoSave] Saved! Version " + lastSavedVersion +
" (" + document.size() + " items)");
}
}
}
Output:
| [Edit] Added | "Hello World" (v1) |
| [Edit] Added | "Adding second paragraph" (v2) |
| [Edit] Added | "Fixing typos" (v3) |
| [Edit] Added | "Final changes" (v4) |
Real-World Use Case: Heartbeat Monitor
Example
public class HeartbeatMonitor {
private static volatile long lastActivity = System.currentTimeMillis();
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Heartbeat Monitor (Daemon) ===\n");
// Daemon: monitors inactivity
Thread heartbeat = new Thread(() -> {
while (true) {
long idle = System.currentTimeMillis() - lastActivity;
if (idle > 3000) {
System.out.println(" ⚠️ [Monitor] Warning: No activity for " +
(idle / 1000) + "s!");
} else {
System.out.println(" 💓 [Monitor] Heartbeat OK (idle: " + idle + "ms)");
}
try { Thread.sleep(1000); } catch (InterruptedException e) { return; }
}
}, "Heartbeat");
heartbeat.setDaemon(true);
heartbeat.start();
// Simulate application activity
for (int i = 0; i < 4; i++) {
System.out.println("[App] Processing request " + (i + 1));
lastActivity = System.currentTimeMillis();
Thread.sleep(800);
}
System.out.println("[App] All requests done. Exiting.");
}
}
Output
=== Heartbeat Monitor (Daemon) === [Main] Application running... [Monitor] ❤️ Heartbeat OK (1s interval) [Monitor] ❤️ Heartbeat OK [Monitor] ❤️ Heartbeat OK [Main] Application finished. (Monitor daemon thread stops - JVM exits)
Important Rules and Pitfalls
java example
public class DaemonRules {
public static void main(String[] args) {
System.out.println("=== Daemon Thread Rules ===\n");
// Rule 1: Must set daemon BEFORE start()
Thread t = new Thread(() -> {});
t.setDaemon(true); // ✅ OK — before start
t.start();
try {
t.setDaemon(false); // ❌ IllegalThreadStateException!
} catch (IllegalThreadStateException e) {
System.out.println("Rule 1: Cannot setDaemon after start()");
System.out.println(" Error: " + e.getClass().getSimpleName());
}
// Rule 2: Daemon inherits from parent
Thread.currentThread().setName("MainUser");
Thread child = new Thread(() -> {
System.out.println("\nRule 2: Child inherits daemon status from parent");
System.out.println(" Parent (main) isDaemon: " + false);
System.out.println(" Child isDaemon: " + Thread.currentThread().isDaemon());
});
child.start();
try { child.join(); } catch (InterruptedException e) {}
// Rule 3: Daemon threads should NOT do critical I/O
System.out.println("\nRule 3: Don't do critical work in daemon threads!");
System.out.println(" Daemons can be killed mid-operation.");
System.out.println(" Never: write critical data, commit transactions");
System.out.println(" OK: logging, monitoring, caching, GC");
// Rule 4: finally blocks may not execute in daemon threads
System.out.println("\nRule 4: finally blocks in daemons are NOT guaranteed!");
System.out.println(" JVM can kill daemon without running finally.");
}
}Output
=== Daemon Thread Rules === Rule 1: Cannot setDaemon after start() Result: IllegalThreadStateException ✓ Rule 2: Daemon thread inherits parent's daemon status Child of daemon is daemon: true Child of user thread is user: true Rule 3: JVM exits when only daemon threads remain User thread done. JVM will exit shortly. (Daemon work may be incomplete)
Common Mistakes
1. Setting daemon after start()
java example
Thread t = new Thread(() -> {});
t.start();
t.setDaemon(true); // ❌ IllegalThreadStateException!2. Doing critical work in daemon threads
java example
// ❌ BAD: File write might be cut short!
Thread saver = new Thread(() -> {
// This might never complete — daemon can be killed anytime!
writeToFile(importantData);
});
saver.setDaemon(true);
saver.start();3. Assuming finally blocks execute in daemon threads
java example
Thread daemon = new Thread(() -> {
try {
while (true) { Thread.sleep(100); }
} finally {
// ❌ This may NEVER execute!
releaseResources();
}
});
daemon.setDaemon(true);Interview Questions
Q1: What is a daemon thread?
Answer: A daemon thread is a background service thread that doesn't prevent the JVM from exiting. When all user (non-daemon) threads finish, the JVM terminates and all daemon threads are killed immediately. Examples: Garbage Collector, Finalizer thread.
Q2: How do you create a daemon thread?
Answer: Call thread.setDaemon(true) BEFORE calling thread.start(). Setting it after start throws IllegalThreadStateException.
Q3: What happens to daemon threads when the JVM shuts down?
Answer: They are immediately and abruptly terminated. No finally blocks are guaranteed to run, no shutdown hooks are called for them specifically. Any I/O operation in progress may be left incomplete.
Q4: Can the main thread be a daemon thread?
Answer: No. The main thread is always a user (non-daemon) thread. You cannot call setDaemon(true) on it because it's already started.
Q5: Do child threads inherit the daemon status of their parent?
Answer: Yes. A thread created by a daemon thread is also a daemon. A thread created by a user thread is also a user thread. You can override this by calling setDaemon() before start().
Q6: When should you use daemon threads?
Answer: For background services that support the main application but shouldn't keep it alive: auto-save, heartbeat monitoring, cache cleanup, garbage collection, log flushing, session timeout checking. Never for critical data writes or transactions.
Q8: What happens to daemon thread's finally block when JVM shuts down?
A: It does NOT execute! When all user threads finish, the JVM exits immediately, killing all daemon threads without running their finally blocks. This is a critical difference — never put important cleanup (file saves, database commits) in daemon threads because there's no guarantee they'll complete.
Q9: Can you change a thread's daemon status after it has started?
A: No. Calling setDaemon() after start() throws IllegalThreadStateException. Daemon status must be set before the thread starts. Once running, a thread's daemon/user classification is fixed for its lifetime.
Q10: What are real-world examples of daemon threads in Java?
A: (1) Garbage Collector — reclaims memory in background. (2) Signal dispatcher thread. (3) Finalizer thread. (4) JMX monitoring threads. (5) Timer threads for housekeeping. In applications: (6) Log flushing, (7) Cache cleanup, (8) Heartbeat/health-check threads, (9) Auto-save background threads.
Q11: Do child threads inherit daemon status from parent?
A: Yes! A new thread inherits the daemon status of the thread that creates it. If a daemon thread creates a child thread, that child is also a daemon by default. If a user thread creates a child, it's a user thread. Override with setDaemon() before start().
Q12: What is the relationship between daemon threads and thread pools?
A: By default, ExecutorService creates user threads (preventing JVM shutdown). To create daemon thread pools, provide a custom ThreadFactory: Executors.newFixedThreadPool(4, r -> { Thread t = new Thread(r); t.setDaemon(true); return t; }). Use daemon pools for non-critical background tasks.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Daemon Threads in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, multithreading, daemon, thread
Related Java Master Course Topics
Continue learning this concept
MultithreadingCreating Threads in JavaComplete guide to creating threads in Java — extending Thread class, implementing Runnable interface, lambda expressions, comparison of approaches, and when to use each method.MultithreadingInter-Thread Communication in JavaComplete guide to Inter-Thread Communication in Java — wait(), notify(), notifyAll(), producer-consumer pattern, and how threads coordinate using object monitors.MultithreadingThread Class in JavaComplete guide to the Thread class in Java — constructors, important methods (sleep, join, yield, interrupt), thread naming, thread groups, and practical usage patterns.MultithreadingThread IntroductionComplete introduction to Multithreading in Java — what threads are, processes vs threads, why multithreading matters, concurrency vs parallelism, and how the JVM manages threads.MultithreadingThread Life Cycle in JavaComplete guide to Thread Life Cycle states in Java — NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED, state transitions, and how to observe thread states programmatically.MultithreadingThread Priority in JavaComplete guide to Thread Priority in Java — priority constants, setting priorities, how the thread scheduler uses priorities, priority inheritance, and why priorities are unreliable for correctness.