User Thread Vs. Daemon Thread in Java

In the realm of Java programming, threads play a pivotal role in enabling concurrent execution of tasks. Threads are lightweight subprocesses that can run concurrently within a single process. Java offers two types of threads: user threads and daemon threads. Each type serves a distinct purpose and exhibits unique behavior. In this section, we'll dive into the differences between user threads and daemon threads, explore their characteristics, and provide a hands-on example to demonstrate their functionalities.

User Threads

User threads, as the name implies, are threads that are initiated by the user or programmer. These threads have a primary role in the execution of the program and are responsible for performing essential tasks. They continue running until they complete their designated tasks or until the program explicitly terminates them. User threads hold the execution of the program until they finish their execution, ensuring that all the tasks are completed seamlessly.

A key characteristic of user threads is that they prevent the Java Virtual Machine (JVM) from terminating until all user threads have finished their execution. This ensures that important operations are completed before the program comes to an end. User threads are suited for tasks like handling user interactions, performing calculations, and managing data structures.

Here's an example Java program that demonstrates the concept of user threads.

UserThreadExample.java

public class UserThreadExample {
    public static void main(String[] args) {
        // Creating a user thread
        Thread userThread = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("User Thread: Count " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // Starting the user thread
        userThread.start();
        // Main thread continues its work
        for (int i = 1; i <= 3; i++) {
            System.out.println("Main Thread: Working " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Main Thread: Done");
    }
}

Output:

Main Thread: Working 1
User Thread: Count 1
Main Thread: Working 2
User Thread: Count 2
Main Thread: Working 3
User Thread: Count 3
User Thread: Count 4
User Thread: Count 5
Main Thread: Done

Daemon Threads

On the other hand, daemon threads are threads that run in the background, providing support to user threads. Unlike user threads, daemon threads don't prevent the JVM from terminating if there are no remaining non-daemon threads. They exist to provide auxiliary services to the user threads, and as soon as all user threads complete, the daemon threads are abruptly terminated, without completing their tasks.

Daemon threads are particularly useful for tasks that need continuous maintenance but aren't critical for the program's execution. A classic example is the garbage collector in Java, which runs as a daemon thread to reclaim memory occupied by objects that are no longer in use.

Understanding the Difference: Use Cases

The distinction between user threads and daemon threads can be summarized as follows:

User Threads:
1. Initiated by the programmer.
2. Crucial for the program's execution.
3. Prevent the JVM from terminating until all user threads finish.
4. Suited for tasks that must be completed before the program exits.
Daemon Threads:
1. Often initiated by the programmer.
2. Not critical for the program's execution.
3. Don't prevent the JVM from terminating, even if they're running.
4. Suitable for tasks that run in the background and support user threads.

Example of User Threads and Daemon Threads

Let's delve into a hands-on example to better comprehend the behavior of user threads and daemon threads. Consider a scenario where we simulate a simple messaging application. We'll use user threads to represent active conversations and daemon threads to manage notifications.

In the following example, we have created a user thread representing a messaging conversation and a daemon thread responsible for sending notifications. The daemon thread is set as a daemon using the setDaemon(true) method. As we run the program, we notice that even if the main thread completes, the user thread continues to run until it completes its task. However, the daemon thread might not finish all its notifications if the main thread completes quickly.

ThreadExample.java

public class ThreadExample {
    public static void main(String[] args) {
        // Creating a user thread for a messaging conversation
        Thread userThread = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("User: Sending message " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // Creating a daemon thread for notifications
        Thread daemonThread = new Thread(() -> {
            for (int i = 1; i <= 3; i++) {
                System.out.println("Daemon: Notification " + i);
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        daemonThread.setDaemon(true); // Set the thread as daemon
        // Starting the threads
        userThread.start();
        daemonThread.start();
        System.out.println("Main: All threads started");
    }
}

Output:

Main: All threads started
Daemon: Notification 1
User: Sending message 1
Daemon: Notification 2
User: Sending message 2
Daemon: Notification 3
User: Sending message 3
User: Sending message 4
User: Sending message 5

In this output, the user thread continues to send messages while the daemon thread manages notifications in the background. Note that if the main thread exits before the daemon thread completes, the daemon thread might not finish its notifications.

In Summary, Understanding the distinction between user threads and daemon threads is crucial for effective multithreaded programming in Java. User threads serve as the backbone of a program's execution, while daemon threads work silently in the background, providing auxiliary support to user threads. By employing both types of threads judiciously, developers can create efficient and responsive applications that cater to various tasks and user interactions.

Next TopicCollections Vs. Streams in Java

← prev next →