In Java, a daemon thread is a service provider thread that aids the user thread. Its survival is at the mercy of user threads; hence, when every user thread is killed, the JVM immediately kills this thread.<\/p>\n
Many Java daemon threads, such as the finalizer and gc (Garbage Collector), are running automatically.<\/p>\n
Points to keep in mind when using Java\u2019s Daemon Thread:<\/strong><\/p>\n The daemon thread’s sole function is to assist the user thread with background supporting tasks. Why should JVM continue to run this thread if there is no user thread? For this reason, if there isn’t a user thread, JVM kills the daemon thread.<\/p>\n Background Threads:<\/strong> Daemon threads are threads that provide support to user threads, performing tasks such as garbage collection, logging, or other maintenance activities. They run in the background without preventing the program from terminating when all user threads finish their execution.<\/p>\n Non-Critical Tasks:<\/strong> Daemon threads are typically used for tasks that are not critical to the main functionality of the program. They are often used for housekeeping activities or background processes that can be safely terminated if all user threads have been completed.<\/p>\n Termination Behavior:<\/strong> If all user threads in a program complete their execution, the Java Virtual Machine (JVM) can exit even if daemon threads are still running. In contrast, if any user threads are still active, the JVM will not exit, ensuring that the program remains functional.<\/p>\n Creation:<\/strong> Daemon threads can be created by invoking the setDaemon(true) method on a thread object before starting it. This marks the thread as a daemon thread. By default, threads created by the program are user threads unless explicitly marked as daemon threads.<\/p>\n Example Use Cases:<\/strong> Examples of daemon thread tasks include background logging, automatic data synchronization, and regular cleanup or maintenance of resources.<\/p>\n Lifecycle:<\/strong> Daemon threads have the same lifecycle as user threads, including states like NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED. They differ mainly in their impact on program termination.<\/p>\n Careful Resource Handling:<\/strong> Since daemon threads can be abruptly terminated when the main program exits, it’s important to ensure that they don’t perform critical tasks or leave resources in an inconsistent state.<\/p>\n Garbage Collection:<\/strong> Daemon threads can assist in garbage collection activities by marking and cleaning up objects that are no longer reachable.<\/p>\n Implementation:<\/strong> Daemon threads are implemented using the setDaemon(boolean on) method provided by the Thread class in Java.<\/p>\n All we have to do is call Thread.setDaemon() to make a thread a daemon thread. We’ll use the Thread class extension NewThread in this example.<\/p>\n The daemon status of the thread that created it is inherited by all other threads. Any thread started inside the main method is automatically a user thread because the main thread is one.<\/p>\n Only after the Thread object has been constructed and the thread hasn’t been started can the function setDaemon() be used.<\/p>\n An IllegalThreadStateException will be thrown if setDaemon() is attempted while a thread is active:<\/strong><\/p>\n Java.lang is used.Java daemon thread is provided with two methods by the thread class.<\/p>\n No Preventing JVM Exit:<\/strong> When all user threads have completed running, daemon threads cannot stop the JVM from quitting. Regardless of whether any daemon threads are active, the JVM stops itself if all user threads are finished with their duties.<\/p>\n Automatic Termination:<\/strong> Daemon threads are unable to prevent the JVM from shutting down once all user threads have finished operating. The JVM shuts down on its own if all user threads have completed their tasks, regardless of whether any daemon threads are running.<\/p>\n Low Priority:<\/strong> Among all Java threads, daemon threads have the lowest priority.<\/p>\n Example 1:<\/strong><\/p>\n Output:<\/strong> Explanation:<\/strong><\/p>\n It is established that the Thread class is extended by the class TechVidvan.<\/p>\n Within the TechVidvan class’s execute method:<\/strong><\/p>\n The primary method is:<\/strong><\/p>\n The run method determines if each thread is a user thread or a daemon thread as it runs and prints the appropriate message.<\/p>\n The main thread is always a non-daemon thread by default. All other threads, on the other hand, inherit their parent thread’s daemon characteristics. If the parent thread is a daemon, the child thread will also be one, and vice versa if the parent thread is not a daemon.<\/p>\n Example 2:<\/strong><\/p>\n Output:<\/strong> Explanation:<\/strong><\/p>\n This technique designates whether the active thread is a user thread or a daemon thread. The tU.setDaemon(true) method can be used to turn a user thread into a daemon, while the tD.setDaemon(false) method can be used to turn a daemon thread into a user thread.<\/p>\n Syntax:<\/strong><\/p>\n Parameters:<\/strong><\/p>\n Indicates that this thread is a daemon thread if true.<\/p>\n Exceptions in a Daemon Thread:<\/strong><\/p>\n This technique is used to determine whether the active thread is a daemon. If the thread is a daemon, it returns true. It returns false if not.<\/p>\n Syntax:<\/strong><\/p>\n Returns:<\/strong><\/p>\n If this thread is a daemon thread, this method returns true; otherwise, it returns false.<\/p>\n Program 1:<\/strong><\/p>\n Output:<\/strong> Explanation:<\/strong><\/p>\n IllegalThreadStateException is thrown if the setDaemon() method is called after the thread has been started.<\/p>\n Program 2:<\/strong><\/p>\n Runtime Exception:<\/strong><\/p>\n Output:<\/strong> Explanation:<\/strong><\/p>\n Priority:<\/strong> The JVM shuts down when a process has just daemon threads left. This makes sense because a daemon thread doesn’t need to serve another thread while only daemon threads are active. In summary, daemon threads in Java are designed for background tasks and non-essential processes that provide support to user threads. They allow a program to perform auxiliary activities without keeping the program running indefinitely after its main functionality has been completed.<\/p>\n","protected":false},"excerpt":{"rendered":" In Java, a daemon thread is a service provider thread that aids the user thread. Its survival is at the mercy of user threads; hence, when every user thread is killed, the JVM immediately...<\/p>\n","protected":false},"author":1,"featured_media":89441,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[183],"tags":[5418,5419,5420,250,5421],"class_list":["post-89376","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-daemon-thread","tag-daemon-thread-in-java","tag-java-daemon-thread","tag-learn-java","tag-what-is-daemon-thread"],"yoast_head":"\n\n
If there is no user thread, why does JVM kill the daemon thread?<\/h2>\n
Creating a Daemon Thread:<\/h3>\n
NewThraed daemonThread = new NewThread();\ndaemonThraed.setDaemon(true);\ndaemonThraed.start();<\/pre>\n
@Test(excepted = IllegalThreadStateException.class)\nPublic void whenSetDaemonWhileRunning_thenIllegalThreadStateException()\n{\n NewThread daemonThread = new NewThread();\ndaemonThraed.start();\ndaemonThread.setDaemon(true);\n}<\/pre>\nJava Daemon thread methods by Thread class:<\/h3>\n
\n\n
\n SI.No<\/span><\/td>\n \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Method<\/span><\/td>\n \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Description<\/span><\/td>\n<\/tr>\n \n \u00a0 \u00a0 1<\/span><\/td>\n setDaemon(boolean status) is a public void.<\/span><\/td>\n It determines whether the active thread is a daemon thread or a user thread.<\/span><\/td>\n<\/tr>\n \n \u00a0 \u00a0 2<\/span><\/td>\n isDemand(), a public boolean.\u00a0<\/span><\/td>\n To verify if the current process is a daemon.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Properties of Java Daemon Thread:<\/h3>\n
Program:<\/h3>\n
public class TechVidvan extends Thread {\npublic void run() {\nif(Thread.currentThread().isDaemon())\n{\nSystem.out.println(\"TechVidvan thread work\");\n}\nelse{\nSystem.out.println(\"user thread work\");\n}\n}\npublic static void main(String[] args) {\nTechVidvan t1=new TechVidvan();\nTechVidvan t2=new TechVidvan();\nTechVidvan t3=new TechVidvan();\nt1.setDaemon(true);\nt1.start();\nt2.start();\nt3.start();\n}\n}<\/pre>\n
\nTechVidvan thread work
\nuser thread work
\nuser thread work<\/p>\n\n
\n
Default Nature of Daemon Thread:<\/h3>\n
class TechVidvanJava extends Thread {\npublic void run() {\nSystem.out.println(\"Name:\"+Thread.currentThread().getName());\nSystem.out.println(\"Daemon:\"+Thread.currentThread().isDaemon());\n}\npublic static void main(String[] args){\nTechVidvanJava t1=new TechVidvanJava();\nTechVidvanJava t2=new TechVidvanJava();\nt1.start();\nt1.setDaemon(true);\nt2.start();\n}\n}<\/pre>\n
\nException in thread “main” java.lang.IllegalThreadStateException
\nat java.base\/java.lang.Thread.setDaemon(Thread.java:1406)
\nat TechVidvanJava.main(TestDaemonThread2.java:10)
\nName: <\/strong>Thread-0
\nDaemon: <\/strong>false<\/p>\n\n
Methods of Daemon Thread:<\/h3>\n
1. Void setDaemon (boolean status):<\/h4>\n
Public final void setDaemon (boolean on)<\/pre>\n
\n\n
\n SI.No<\/span><\/td>\n \u00a0 EXCEPTIONS<\/span><\/td>\n \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 Description<\/span><\/td>\n<\/tr>\n \n 1<\/span><\/td>\n IllegalThreadStateException<\/span><\/td>\n The setDaemon() method will throw an error if it is used after the thread has begun.<\/span><\/td>\n<\/tr>\n \n 2<\/span><\/td>\n SecurityException<\/span><\/td>\n After the thread has begun, if you use the setDaemon() method, it will throw an error.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n 2. Boolean isDemand():<\/h4>\n
Public final boolean isDaemon()<\/pre>\n
public class DaemonThread extends Thread\n{\n public DaemonThread(String name){\n super(name);\n }\n \n public void run()\n {\n if(Thread.currentThread().isDaemon())\n {\n System.out.println(getName() + \" is Daemon thread\");\n }\n \n else\n {\n System.out.println(getName() + \" is User thread\");\n }\n }\n public static void main(String[] args)\n {\n DaemonThread t1 = new DaemonThread(\"t1\");\n DaemonThread t2 = new DaemonThread(\"t2\");\n DaemonThread t3 = new DaemonThread(\"t3\");\n t1.setDaemon(true);\n t1.start();\n t2.start();\n t3.setDaemon(true);\n t3.start(); \n }\n}<\/pre>\n
\nt3 is Daemon thread
\nt2 is User thread
\nt1 is Daemon thread<\/p>\n\n
Exceptions in a Daemon Thread:<\/h3>\n
public class DaemonThread extends Thread\n{\n public void run()\n {\n System.out.println(\"Thread name: \" + Thread.currentThread().getName());\n System.out.println(\"Check if its DaemonThread: \"\n + Thread.currentThread().isDaemon());\n }\n public static void main(String[] args)\n {\n DaemonThread t1 = new DaemonThread();\n DaemonThread t2 = new DaemonThread();\n t1.start();\n t1.setDaemon(true);\n t2.start();\n }\n}<\/pre>\nException in thread \"main\" java.lang.IllegalThreadStateExceptionat java.base\/java.lang.Thread.setDaemon(Thread.java:1406)\n at DaemonThread.main(DaemonThread.java:14)<\/pre>\n
\nThread name:<\/strong> Thread-0
\nCheck if its DaemonThread:<\/strong> false<\/p>\n\n
Daemons vs User Threads:<\/h3>\n
\nUsage:<\/strong> User threads are mostly supported in the background by daemon threads. Without interfering with user actions, they manage tasks that assist the main execution.<\/p>\nProperties of Daemon Thread:<\/h4>\n
\n
Conclusion<\/h3>\n