Daemon Thread In Java | Creation, Applications & More (+Examples)

20 mins read

In Java, threads are the backbone of multitasking and concurrency, enabling programs to perform multiple operations simultaneously. Among the various types of threads, daemon threads hold a unique position. Unlike regular user threads that complete their tasks before the application terminates, daemon threads are designed to run in the background, providing essential services to user threads without holding up the application's lifecycle.

In this article, we will explore the concept of daemon threads, how they differ from user threads, their practical applications, and the methods to create and manage them in Java. By the end, you'll have a comprehensive understanding of how to effectively use daemon threads in your Java programs.

What Is A Daemon Thread In Java?

A daemon thread in Java programming is a background thread that supports the execution of user threads by providing auxiliary services. Unlike regular threads, daemon threads are not intended to perform tasks critical to the application; instead, they handle low-priority tasks like cleanup and maintenance. The JVM (Java Virtual Machine) does not wait for daemon threads to complete before exiting, meaning they terminate automatically once all user threads have finished execution.

Some Examples Of Daemon Threads:

• Garbage Collection (GC): Java’s garbage collector is a classic example of a daemon thread that manages memory by removing unused objects.
• Background Logging: Logging frameworks often use daemon threads to write logs to files or servers asynchronously.

Key Features Of Daemon Threads In Java

Daemon threads play a crucial role in Java's multithreading model. Some of it’s key features are:

1. Background Execution: Daemon threads run silently in the background, supporting the main application without interfering with its flow.
2. Non-Blocking JVM Exit: The JVM will terminate as soon as all user threads complete, even if daemon threads are still running.
3. Auxiliary Role: Daemon threads are designed to assist user threads by performing non-critical tasks, such as logging or garbage collection.
4. Lifecycle Dependency: The lifecycle of a daemon thread depends on user threads; they automatically end when there are no active user threads.

Default Nature Of Daemon Threads In Java

In Java, threads are non-daemon (user threads) by default, meaning that any thread created without explicitly being set as a daemon will act as a user thread. This default behavior ensures that new threads are part of the application's main tasks and do not terminate prematurely while the JVM is running.

Explore this amazing course and master all the key concepts of Java programming effortlessly!

User Threads Vs. Daemon Threads In Java

While user threads are essential for the primary execution of an application, daemon threads provide silent background support. Understanding the distinction between user and daemon threads is vital to grasp the role of each in Java applications:

Methods For Daemon Threads In The Thread Class

The Thread class in Java provides specific methods to work with daemon threads. These methods allow us to set, check, and manage daemon threads effectively.

1. The setDaemon(boolean on) Method

• Description: Sets the daemon status of a thread.
• Parameters: on (boolean) — If true, marks the thread as a daemon thread; otherwise, it is a user thread.
• Usage: Must be called before starting the thread, or it throws IllegalThreadStateException.
• Example:
  

  Thread thread = new Thread();
  thread.setDaemon(true); // Mark as a daemon thread

2. The isDaemon() Method

• Description: Checks whether a thread is a daemon thread.
• Returns: A boolean — true if the thread is a daemon thread, false otherwise.
• Usage: Can be called at any point to determine the daemon status of a thread.
• Example:
  

  Thread thread = new Thread();
  System.out.println("Is thread a daemon? " + thread.isDaemon());

3. The start() Method

• Description: Starts the execution of a thread.
• Usage with Daemon Threads: Daemon threads must be marked using setDaemon(true) before calling this method.
• Example:
  

  Thread daemonThread = new Thread(() -> System.out.println("Daemon running..."));
  daemonThread.setDaemon(true);
  daemonThread.start(); // Start the daemon thread

Creating Daemon Threads In Java

Unlike user threads, daemon threads automatically terminate when all user threads finish execution. To create a daemon thread, we start by creating a normal thread and then explicitly set it as a daemon using the setDaemon(true) method before starting the thread.

Steps To Create A Daemon Thread:

1. Create a Thread: Use the Thread class or implement the Runnable interface to define a thread.
2. Set as Daemon: Call the setDaemon(true) method on the thread object before starting it. If this is done after starting the thread, an IllegalThreadStateException is thrown.
3. Start the Thread: Use the start() method to begin the execution of the daemon thread.
4. Verify Daemon Status: Use the isDaemon() method to confirm whether the thread is a daemon.

Let’s look at a code example to understand the creation of daemon thread in Java-

Code Example: 

public class DaemonThreadDemo {

    public static void main(String[] args) {

        // Create a thread
        Thread daemonThread = new Thread(() -> {

            while (true) {
                System.out.println("Daemon thread is running...");
                try {
                    Thread.sleep(500); // Sleep for 500 milliseconds
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });

        // Set the thread as a daemon
        daemonThread.setDaemon(true);

        // Verify if the thread is a daemon
        System.out.println("Is the thread a daemon? " + daemonThread.isDaemon());

        // Start the thread
        daemonThread.start();

        // Main thread logic
        System.out.println("Main thread is running...");
        try {
            Thread.sleep(2000); // Sleep for 2 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread is finishing...");
    }
}

Output (set code file name as DaemonThreadDemo.java):

Is the thread a daemon? true 
Main thread is running... 
Daemon thread is running... 
Daemon thread is running... 
Daemon thread is running... 
Daemon thread is running... 
Main thread is finishing...

Explanation:

In the above code example-

1. We begin by defining a DaemonThreadDemo class with a main() method. This serves as the entry point of our program.
2. Inside the main method, we create a new thread using a lambda expression. This thread continuously prints "Daemon thread is running..." in an infinite loop.
3. To avoid overwhelming the console, we make the thread pause for 500 milliseconds after each print statement using Thread.sleep(500). If interrupted, it catches the InterruptedException and prints the stack trace.
4. We then set this thread as a daemon by calling daemonThread.setDaemon(true). This ensures that the thread runs in the background and terminates when the main thread finishes.
5. To confirm the daemon status, we use daemonThread.isDaemon() and print the result. This helps us verify that the thread has been correctly marked as a daemon.
6. We start the daemon thread using daemonThread.start(), allowing it to execute its logic concurrently with the main thread.
7. Meanwhile, the main thread prints "Main thread is running..." to the console, signifying its operation.
8. We make the main thread sleep for 2 seconds using Thread.sleep(2000) to simulate some processing time. During this pause, the daemon thread continues its execution.
9. Finally, the main thread prints "Main thread is finishing..." before terminating. At this point, the daemon thread also stops running since it depends on the main thread's lifecycle.

Checking The Daemon Status Of A Thread

In Java, we can check whether a thread is a daemon thread using the isDaemon() method of the Thread class. This method returns a boolean value:

• true if the thread is a daemon.
• false if the thread is a user thread.

The daemon status of a thread determines its role:

• Daemon Threads: Supportive background tasks that terminate when all user threads complete.
• User Threads: Perform core application tasks and keep the JVM running until they finish execution.

Code Example: 

public class CheckDaemonStatus {

    public static void main(String[] args) {

        // Create a user thread (default behavior)
        Thread userThread = new Thread(() -> System.out.println("User thread running..."));

        // Create a daemon thread
        Thread daemonThread = new Thread(() -> System.out.println("Daemon thread running..."));
        daemonThread.setDaemon(true); // Set as daemon

        // Check and print the daemon status of each thread
        System.out.println("Is userThread a daemon? " + userThread.isDaemon());
        System.out.println("Is daemonThread a daemon? " + daemonThread.isDaemon());

        // Start the threads
        userThread.start();
        daemonThread.start();
    }

}

Output (set code file name as CheckDaemonStatus.java):

Is userThread a daemon? false
Is daemonThread a daemon? true
User thread running…
Daemon thread running...

Explanation: 

In the above code example-

1. We start by defining a CheckDaemonStatus class with a main() method as the program's entry point.
2. Inside the main method, we create a thread named userThread. By default, this is a user thread, and its task is to print "User thread running..." when executed.
3. Next, we create another thread named daemonThread. This thread is specifically set as a daemon thread by calling daemonThread.setDaemon(true). Its task is to print "Daemon thread running..." during execution.
4. To verify the type of each thread, we use the isDaemon() method. We check and print whether userThread is a daemon thread, followed by checking daemonThread. This output helps us confirm their respective statuses.
5. We then start both threads using their start() method, allowing them to execute their respective logic concurrently.
6. The userThread completes its task independently of the daemonThread, which is terminated automatically once the main thread finishes execution.

Note: Threads are user threads by default, meaning isDaemon() returns false unless explicitly set otherwise. A thread can be marked as a daemon using the setDaemon(true) method before starting it.

Exceptions In Daemon Threads

Daemon threads in Java, like user threads, can throw exceptions during their execution. However, handling exceptions in daemon threads requires careful attention due to their non-critical role and the following characteristics:

Behavior Of Daemon Threads When An Exception Occurs:

• Abrupt Termination: If an uncaught exception occurs in a daemon thread, it terminates immediately, just like a user thread.
• No Impact on JVM: The JVM remains unaffected as long as user threads are running.
• Risk of Incomplete Tasks: Since daemon threads are often used for auxiliary operations, exceptions can lead to incomplete background tasks.

The different types of exceptions encountered in daemon threads in Java are:

1. Checked Exceptions

These exceptions must be explicitly declared in the method signature or handled using a try-catch block. They occur due to foreseeable and recoverable conditions.

Example Scenarios in Daemon Threads

• InterruptedException: When a daemon thread is sleeping or waiting and is interrupted.
• IOException: If a daemon thread performs I/O operations, such as logging, and encounters issues like file not found or disk write errors. For Example-

Thread daemonThread = new Thread(() -> {
    try {
        Thread.sleep(1000); // Checked exception
    } catch (InterruptedException e) {
        System.out.println("Daemon thread interrupted: " + e.getMessage());
    }
});
daemonThread.setDaemon(true);
daemonThread.start();

2. Unchecked Exceptions (Runtime Exceptions)

These exceptions occur during runtime and do not require explicit handling in the code. They can terminate the daemon thread if unhandled.

Example Scenarios in Daemon Threads

• NullPointerException: Attempting to access a null object.
• ArithmeticException: Performing illegal arithmetic operations, such as division by zero. For Example-

Thread daemonThread = new Thread(() -> {
    try {
        int result = 10 / 0; // Unchecked exception
    } catch (ArithmeticException e) {
        System.out.println("ArithmeticException caught: " + e.getMessage());
    }
});
daemonThread.setDaemon(true);
daemonThread.start();

3. Errors (Critical Issues)

Errors indicate severe problems that the application cannot recover from, such as memory issues or JVM crashes. These are generally not caught in a try-catch block.

Example Scenarios in Daemon Threads

• StackOverflowError: Infinite recursion in a daemon thread.
• OutOfMemoryError: When a daemon thread tries to allocate memory, but the heap is full. For Example-

Thread daemonThread = new Thread(() -> {
    try {
        recursiveCall(); // This will cause StackOverflowError
    } catch (StackOverflowError e) {
        System.out.println("Caught StackOverflowError: " + e.getMessage());
    }
});

daemonThread.setDaemon(true);
daemonThread.start();
// Recursive method to trigger StackOverflowError
static void recursiveCall() {
    recursiveCall();
}

4. Thread-Specific Exceptions

Daemon threads may also encounter exceptions unique to threading operations:

• IllegalThreadStateException: Occurs when attempting to change the daemon status of a thread after it has started. For Example-

Thread daemonThread = new Thread(() -> System.out.println("Running daemon thread"));
daemonThread.start();
try {
    daemonThread.setDaemon(true); // Will throw IllegalThreadStateException
} catch (IllegalThreadStateException e) {
    System.out.println("IllegalThreadStateException caught: " + e.getMessage());
}

Best Practices for Exception Handling in Daemon Threads:

• Handle Checked Exceptions: Always use try-catch blocks for predictable issues like I/O or sleep interruptions.
• Anticipate Runtime Exceptions: Test and validate daemon thread logic to avoid unexpected runtime errors.
• Avoid Critical Operations: Do not assign tasks prone to errors or unrecoverable failures to daemon threads.
• Use Logging: Log exceptions to monitor and debug issues encountered in daemon threads effectively.
• Minimal Dependencies: Avoid critical dependencies on daemon threads for application integrity.

Therefore, by understanding and handling these exceptions, we can make daemon threads more reliable and predictable in Java applications.

Limitations Of Daemon Threads In Java

While daemon threads are useful for background operations, they come with significant limitations that make them unsuitable for critical tasks. Some of these limitations are as follows:

1. Unpredictable Termination: Daemon threads are terminated abruptly when all user threads finish execution, regardless of whether the daemon thread has completed its task. This means that if a daemon thread is performing a critical operation, such as writing data to a file or completing a long-running computation, it may not finish properly, leading to potential data corruption or incomplete operations.
2. No Guarantee of Completion: Since daemon threads are not essential for the application’s completion, they are subject to termination when the JVM shuts down. This means there is no guarantee that a daemon thread will finish its execution, even if it’s in the middle of important work. For example, a daemon thread that is performing periodic maintenance or logging may leave tasks unfinished if the JVM exits unexpectedly.
3. Limited Control Over Execution: Daemon threads are designed to run in the background without user intervention. However, this means they do not have as much control or attention from the developer. If a daemon thread is stuck or running into issues (e.g., deadlocks), it may go unnoticed since it doesn’t block the application, making debugging and troubleshooting more difficult.
4. Resource Management Challenges: Daemon threads typically do not manage resources such as database connections or file handles as effectively as user threads. If a daemon thread terminates unexpectedly, it may leave resources in an inconsistent state, such as unclosed file streams or uncommitted database transactions, leading to potential memory leaks or resource contention.
5. Lack of Synchronization Guarantees: Daemon threads may not synchronize their operations with user threads, which could lead to race conditions or inconsistent states if both types of threads access shared resources concurrently. If a daemon thread is performing a task while the user thread expects the resource to be in a specific state, there could be conflicts leading to unexpected behavior.
6. Inability to Handle Critical Tasks: Daemon threads are not suitable for critical tasks that must be guaranteed to complete. For example, operations like saving important user data or handling transactions cannot be safely handled by daemon threads since the JVM may terminate the daemon thread before it finishes, resulting in lost data or transactions.
7. No Exception Handling by Default: In daemon threads, uncaught exceptions may not be handled as effectively as in user threads. If a daemon thread throws an exception and it's not caught within the thread, the thread may terminate, and the exception may go unnoticed. This lack of visibility makes it more difficult to identify and address issues with daemon threads.
8. Performance Impact: Daemon threads, if not properly managed, can affect the overall performance of an application. For instance, if a daemon thread is running tasks like garbage collection, logging, or background updates too frequently, it may consume excessive CPU cycles or memory resources, impacting the performance of user threads and the application as a whole.
9. Difficulty in Testing and Debugging: Since daemon threads run in the background, they are often challenging to test and debug. If a problem arises in a daemon thread, it may not be easy to reproduce the issue, as the thread's execution is usually invisible to the developer. This makes tracking down issues in daemon threads more complicated compared to user threads.
10. Limited Usage Scenarios: Daemon threads are primarily intended for non-essential background tasks, and as such, they are not appropriate for all use cases. They should not be used for tasks that require high reliability, such as processing critical business logic or handling important transactions. Their use should be reserved for auxiliary tasks that can be safely abandoned when the JVM shuts down.

Sharpen your coding skills with Unstop's 100-Day Coding Sprint and compete now for a top spot on the leaderboard!

Practical Applications Of Daemon Threads In Java

Daemon threads are ideal for performing background tasks that support the primary (user) threads without blocking the program's execution. Below are some of their key practical applications:

1. Garbage Collection (GC)

• Purpose: Automatically manages memory by reclaiming unused objects, preventing memory leaks.
• Daemon Nature: Runs in the background without requiring explicit control, ensuring smooth execution of user threads.
• Example: The JVM's garbage collector is a classic example of a daemon thread, responsible for reclaiming heap memory occupied by unreachable objects.

2. Background Logging

• Purpose: Records application logs in the background for debugging, monitoring, and auditing purposes.
• Daemon Nature: Ensures that log collection does not interrupt the main application flow.
• Example:

Thread loggingThread = new Thread(() -> {
    while (true) {
        System.out.println("Logging application status...");
        try {
            Thread.sleep(5000); // Log every 5 seconds
        } catch (InterruptedException e) {
            System.out.println("Logging thread interrupted.");
        }
    }
});

loggingThread.setDaemon(true);
loggingThread.start();

3. Task Scheduling

• Purpose: Schedules and executes tasks periodically, such as sending notifications or performing database cleanup.
• Daemon Nature: Operates in the background without blocking user threads.
• Example: A scheduler that sends reminders at regular intervals.

4. Resource Monitoring

• Purpose: Tracks resource utilization (CPU, memory, disk, etc.) and notifies administrators if thresholds are exceeded.
• Daemon Nature: Provides continuous monitoring without affecting the application's performance.
• Example: 

Thread resourceMonitor = new Thread(() -> {
    while (true) {
        System.out.println("Monitoring resources...");
        try {
            Thread.sleep(1000); // Monitor every second
        } catch (InterruptedException e) {
            System.out.println("Resource monitoring interrupted.");
        }
    }
});
resourceMonitor.setDaemon(true);
resourceMonitor.start();

5. Database Connection Pooling

• Purpose: Manages a pool of database connections to optimize resource usage and improve performance.
• Daemon Nature: Handles the creation and cleanup of idle connections in the background.

6. Cache Management

• Purpose: Updates, invalidates, or cleans cache data periodically to ensure accuracy and efficiency.
• Daemon Nature: Operates behind the scenes to support the application’s caching mechanism.

7. Security and Maintenance Tasks

• Purpose: Executes security checks, backups, and other maintenance tasks without user intervention.
• Daemon Nature: Performs tasks silently in the background to avoid interrupting application workflows.

8. Chat Applications

• Purpose: Listens for incoming messages or notifications while the user interacts with the application.
• Daemon Nature: Runs in the background to support real-time communication.
• Example: A messaging app’s thread to fetch new messages continuously.

9. Automatic Updates

• Purpose: Checks for and downloads updates in the background without disrupting the user experience.
• Daemon Nature: Operates unobtrusively while the application runs.

10. System Services

• Purpose: Provides auxiliary services like printing, networking, or file indexing in an operating system or application.
• Daemon Nature: Ensures smooth operation without active user involvement.

Common Mistakes To Avoid When Working With Daemon Threads In Java

When working with daemon threads in Java, try to avoid the following:

1. Using Daemon Threads for Critical Tasks: Daemon threads should not be used for essential operations like saving user data or handling transactions, as they may be terminated abruptly when the JVM shuts down.
2. Not Setting Daemon Flag Before Starting: Always set the daemon flag (setDaemon(true)) before calling start() on a thread. Setting it after starting the thread results in an IllegalThreadStateException.
3. Assuming Daemon Threads Will Always Complete: Since daemon threads can be terminated when the JVM shuts down, don't assume they will always finish their tasks. Design tasks to handle incomplete work.
4. Ignoring Exception Handling: Daemon threads can terminate due to unhandled exceptions. Proper exception handling is crucial to prevent them from exiting unexpectedly.
5. Overloading with Too Many Daemon Threads: Creating too many daemon threads can cause performance issues. Limit the number of threads based on your application's needs.
6. Neglecting Thread Interruption Handling: Daemon threads can be interrupted. Ensure they handle interruptions and terminate cleanly to avoid resource leaks.
7. Assuming Daemon Threads Don’t Affect Main Thread: Daemon threads may consume system resources, affecting the performance of user threads. Monitor their resource usage to avoid performance degradation.
8. Failing to Synchronize Shared Resources: Daemon threads accessing shared resources must be synchronized properly to prevent race conditions or data inconsistency.
9. Assuming Daemon Threads Are Always Low Priority: Daemon threads can have their priority adjusted with setPriority(). Don’t assume they always run with low priority.
10. Not Accounting for JVM Shutdown Behavior: Daemon threads are terminated when the JVM shuts down. Ensure that they are used for non-essential tasks that can be safely interrupted.
11. Over-Relying on Daemon Threads for Long Tasks: Daemon threads are best suited for short-lived tasks. For long-running tasks, use user threads to ensure completion.

Thus, avoiding these mistakes helps ensure daemon threads are used effectively without introducing unexpected issues.

Are you looking for someone to answer all your programming-related queries? Let's find the perfect mentor here.

Conclusion 

In Java, daemon threads are useful for running background tasks that support the main application, like garbage collection or logging. They allow the JVM to exit without waiting for these threads to finish. However, they come with limitations, such as being abruptly terminated when the JVM shuts down, and they should not be used for critical tasks. By understanding their behavior, managing resources properly, and using them for non-essential operations, you can leverage daemon threads effectively without risking data loss or performance issues in your application.

Frequently Asked Questions

Q. What is a daemon thread in Java?

A daemon thread in Java is a thread that runs in the background to perform auxiliary tasks that support the main application. These threads do not prevent the JVM from exiting. When all user threads have finished execution, the JVM can terminate, and daemon threads are automatically stopped without waiting for them to complete their tasks.

Q. How do I create a daemon thread in Java?

To create a daemon thread, you must first create a Thread object, then set it as a daemon thread using the setDaemon(true) method before starting the thread. If the daemon flag is set after calling start(), it will throw an IllegalThreadStateException. For example-

Thread thread = new Thread(() -> {
    System.out.println("Daemon thread running");
});
thread.setDaemon(true); // Set as daemon before starting
thread.start();

Q. Can daemon threads be interrupted?

Yes, daemon threads can be interrupted. Like any other thread, daemon threads can be stopped by calling interrupt() on them. However, since they are typically used for background tasks, you must ensure they handle interruptions properly to avoid leaving resources in an inconsistent state.

Q. What happens if a daemon thread throws an exception?

If an exception occurs in a daemon thread and is not caught, the thread will terminate immediately. Since daemon threads are non-essential, uncaught exceptions in them will not affect the main application. However, it's a good practice to handle exceptions to ensure the background tasks can recover or fail gracefully.

Q. Are daemon threads suitable for long-running tasks?

No, daemon threads are not ideal for long-running tasks. Since they are terminated when the JVM shuts down, they should only be used for tasks that can be interrupted or abandoned without critical consequences. Long-running tasks should be handled by user threads to ensure proper completion.

Q. Can I change a thread to a daemon thread after it has started?

No, you cannot change a thread to a daemon thread once it has started. The daemon flag must be set before the start() method is called. If you try to set it after the thread has started, it will result in an IllegalThreadStateException.

With this, we have come to an end in our discussion on the daemon threads in Java. Here are a few other topics that you might be interested in reading: 

1. Final, Finally & Finalize In Java | 15+ Differences With Examples
2. Super Keyword In Java | Definition, Applications & More (+Examples)
3. How To Find LCM Of Two Numbers In Java? Simplified With Examples
4. How To Find GCD Of Two Numbers In Java? All Methods With Examples
5. 10 Best Books On Java In 2024 For Successful Coders
6. Difference Between Java And JavaScript Explained In Detail
7. Top 15+ Difference Between C++ And Java Explained! (+Similarities)