Home » Java » What is Daemon thread in Java?

What is Daemon thread in Java?

Posted by: admin November 2, 2017 Leave a comment

Questions:

Can anybody tell me what daemon threads are in Java?

Answers:

A daemon thread is a thread that does not prevent the JVM from exiting when the program finishes but the thread is still running. An example for a daemon thread is the garbage collection.

You can use the setDaemon(boolean) method to change the Thread daemon properties before the thread starts.

Questions:
Answers:

A few more points (Reference: Java Concurrency in Practice)

  • When a new thread is created it inherits the daemon status of its
    parent.
  • Normal thread and daemon threads differ in what happens when
    they exit. When the JVM halts any remaining daemon threads are
    abandoned
    :

    • finally blocks are not executed,
    • stacks are not unwound – the JVM just exits.

    Due to this reason daemon threads
    should be used sparingly and it is dangerous to use them for tasks
    that might perform any sort of I/O.

Questions:
Answers:

All the above answers are good. Here’s a simple little code snippet, to illustrate the difference. Try it with each of the values of true and false in setDaemon.

public class DaemonTest {

    public static void main(String[] args) {
        new WorkerThread().start();

        try {
            Thread.sleep(7500);
        } catch (InterruptedException e) {
            // handle here exception
        }

        System.out.println("Main Thread ending") ;
    }

}

class WorkerThread extends Thread {

    public WorkerThread() {
        // When false, (i.e. when it's a user thread),
        // the Worker thread continues to run.
        // When true, (i.e. when it's a daemon thread),
        // the Worker thread terminates when the main 
        // thread terminates.
        setDaemon(true); 
    }

    public void run() {
        int count = 0;

        while (true) {
            System.out.println("Hello from Worker "+count++);

            try {
                sleep(5000);
            } catch (InterruptedException e) {
                // handle exception here
            }
        }
    }
}

Questions:
Answers:

Traditionally daemon processes in UNIX were those that were constantly running in background, much like services in Windows.

A daemon thread in Java is one that doesn’t prevent the JVM from exiting. Specifically the JVM will exit when only daemon threads remain. You create one by calling the setDaemon() method on Thread.

Have a read of Daemon threads.

Questions:
Answers:

Daemon threads are like a service providers for other threads or objects running in the same process as the daemon thread. Daemon threads are used for background supporting tasks and are only needed while normal threads are executing. If normal threads are not running and remaining threads are daemon threads then the interpreter exits.

For example, the HotJava browser uses up to four daemon threads named “Image Fetcher” to fetch images from the file system or network for any thread that needs one.

Daemon threads are typically used to perform services for your application/applet (such as loading the “fiddley bits”). The core difference between user threads and daemon threads is that the JVM will only shut down a program when all user threads have terminated. Daemon threads are terminated by the JVM when there are no longer any user threads running, including the main thread of execution.

setDaemon(true/false) ? This method is used to specify that a thread is daemon thread.

public boolean isDaemon() ? This method is used to determine the thread is daemon thread or not.

Eg:

public class DaemonThread extends Thread {
    public void run() {
        System.out.println("Entering run method");

        try {
            System.out.println("In run Method: currentThread() is" + Thread.currentThread());

            while (true) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException x) {}

                System.out.println("In run method: woke up again");
            }
        } finally {
            System.out.println("Leaving run Method");
        }
    }
    public static void main(String[] args) {
        System.out.println("Entering main Method");

        DaemonThread t = new DaemonThread();
        t.setDaemon(true);
        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException x) {}

        System.out.println("Leaving main method");
    }

}

OutPut:

C:\java\thread>javac DaemonThread.java

C:\java\thread>java DaemonThread
Entering main Method
Entering run method
In run Method: currentThread() isThread[Thread-0,5,main]
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
Leaving main method

C:\j2se6\thread>

Questions:
Answers:

A daemon thread is a thread that is considered doing some tasks in the background like handling requests or various chronjobs that can exist in an application.

When your program only have damon threads remaining it will exit. That’s because usually these threads work together with normal threads and provide background handling of events.

You can specify that a Thread is a demon one by using setDaemon method, they usually don’t exit, neither they are interrupted.. they just stop when application stops.

Questions:
Answers:

Java has a special kind of thread called daemon thread.

  • Very low priority.
  • Only executes when no other thread of the same program is running.
  • JVM ends the program finishing these threads, when daemon threads are
    the only threads running in a program.

What are daemon threads used for?

Normally used as service providers for normal threads.
Usually have an infinite loop that waits for the service request or performs the tasks of the thread.
They can’t do important jobs. (Because we don’t know when they are going to have CPU time and they can finish any time if there aren’t any other threads running. )

A typical example of these kind of threads is the Java garbage collector.

There’s more…

  • You only call the setDaemon() method before you call the start() method. Once the thread is running, you can’t modify its daemon status.
  • Use isDaemon() method to check if a thread is a daemon thread or a user thread.
Questions:
Answers:

One misconception I would like to clarify:

  • Assume that if daemon thread (say B) is created within user thread (say
    A); then ending of this user thread/parent thread (A) will not end
    the daemon thread/child thread (B) it has created; provided user thread is the only
    one currently running.
  • So there is no parent-child relationship on thread ending. All daemon threads (irrespective of where it is created) will end once there is no single live user thread and that causes JVM to terminate.
  • Even this is true for both (parent/child) are daemon threads.
  • If a child thread created from a daemon thread then that is also a daemon thread. This won’t need any explicit daemon thread flag setting.
    Similarly if a child thread created from a user thread then that is also a user thread, if you want to change it, then explicit daemon flag setting is needed before start of that child thread.
Questions:
Answers:

What is Daemon thread in java?

  • Daemon threads can shut down any time in between their flow, Non-Daemon i.e. user thread executes completely.
  • Daemon threads executes at a low priority.
  • Daemon threads are threads that run intermittently in the background as long as other non-daemon threads are running.
  • When all of the non-daemon threads complete, daemon threads terminates automatically.
  • Daemon threads are service providers for user threads running in the same process.
  • The JVM does not care about daemon threads to complete when in Running state, not even finally block also let execute. JVM do give preference to non-daemon threads that is created by us.
  • Daemon threads acts as services in Windows.
  • The JVM stops the daemon threads when all user threads (in contrast to the daemon threads) are terminated. Hence daemon threads can be used to implement, for example, a monitoring functionality as the thread is stopped by the JVM as soon as all user threads have stopped.
Questions:
Answers:

Daemon Thread and User Threads. Generally all threads created by programmer are user thread (unless you specify it to be daemon or your parent thread is a daemon thread). User thread are generally meant to run our programm code. JVM doesn’t terminates unless all the user thread terminate.

Questions:
Answers:

Daemon thread is just like a normal thread except that the JVM will only shut down when the other non daemon threads are not existing. Daemon threads are typically used to perform services for your application.

Questions:
Answers:

Daemon threads are as everybody explained, will not constrain JVM to exit, so basically its a happy thread for Application from exit point of view.

Want to add that daemon threads can be used when say I’m providing an API like pushing data to a 3rd party server / or JMS, I might need to aggregate data at the client JVM level and then send to JMS in a separate thread. I can make this thread as daemon thread, if this is not a mandatory data to be pushed to server.
This kind of data is like log push / aggregation.

Regards,
Manish

Questions:
Answers:

Daemon thread in Java are those thread which runs in background and mostly created by JVM for performing background task like Garbage collection and other house keeping tasks.

Points to Note :

  1. Any thread created by main thread, which runs main method in Java is by default non daemon because Thread inherits its daemon nature from the Thread which creates it i.e. parent Thread and since main thread is a non daemon thread, any other thread created from it will remain non-daemon until explicitly made daemon by calling setDaemon(true).

  2. Thread.setDaemon(true) makes a Thread daemon but it can only be called before starting Thread in Java. It will throw IllegalThreadStateException if corresponding Thread is already started and running.

Difference between Daemon and Non Daemon thread in Java :

1) JVM doesn’t wait for any daemon thread to finish before existing.

2) Daemon Thread are treated differently than User Thread when JVM terminates, finally blocks are not called, Stacks are not unwounded and JVM just exits.

Questions:
Answers:

Daemon thread is like daemon process which is responsible for managing resources,a daemon thread is created by the Java VM to serve the user threads.
example updating system for unix,unix is daemon process.
child of daemon thread is always daemon thread,so by default daemon is false.you can check thread as daemon or user by using “isDaemon()” method.
so daemon thread or daemon process are basically responsible for managing resources.
for example when you starting jvm there is garbage collector running that is daemon thread whose priority is 1 that is lowest,which is managing memory.
jvm is alive as long as user thread is alive,u can not kill daemon thread.jvm is responsible to kill daemon threads.

Questions:
Answers:

Daemon threads are generally known as “Service Provider” thread. These threads should not be used to execute program code but system code. These threads run parallel to your code but JVM can kill them anytime. When JVM finds no user threads, it stops it and all daemon threads terminate instantly. We can set non-daemon thread to daemon using :

setDaemon(true)

Questions:
Answers:

Daemon threads are like assistants. Non-Daemon threads are like front performers. Assistants help performers to complete a job. When the job is completed, no help is needed by performers to perform anymore. As no help is needed the assistants leave the place. So when the jobs of Non-Daemon threads is over, Daemon threads march away.

Questions:
Answers:

Any Java thread can be a daemon thread.

Daemon threads are service providers for other threads running in the same process as the daemon thread. For example, the HotJava browser uses up to four daemon threads named “Image Fetcher” to fetch images from the file system or network for any thread that needs one. The run() method for a daemon thread is typically an infinite loop that waits for a service request.
When the only remaining threads in a process are daemon threads, the interpreter exits. This makes sense because when only daemon threads remain, there is no other thread for which a daemon thread can provide a service.

To specify that a thread is a daemon thread, call the setDaemon method with the argument true. To determine if a thread is a daemon thread, use the accessor method isDaemon.

Hope this may help!!!!!!

Questions:
Answers:

For me, daemon thread it’s like house keeper for user threads.
If all user threads finished , the daemon thread has no job and
killed by JVM.
I explained it in the YouTube video.

Questions:
Answers:

Daemon threads are threads that run in background as long as other non-daemon threads of the process are still running. Thus, when all of the non-daemon threads complete, the daemon threads are terminated. An example for non-daemon thread is the thread running the Main.
A thread is made daemon by calling the setDaemon() method before the thread is started

For More Reference : Daemon thread in Java

Questions:
Answers:

Let’s talk only in code with working examples. I like russ’s answer above but to remove any doubt I had, I enhanced it a little bit. I ran it twice, once with the worker thread set to deamon true (deamon thread) and another time set it to false (user thread). It confirms that the deamon thread ends when the main thread terminates.

public class DeamonThreadTest {

public static void main(String[] args) {

    new WorkerThread(false).start();    //set it to true and false and run twice.

    try {
        Thread.sleep(7500);
    } catch (InterruptedException e) {
        // handle here exception
    }

    System.out.println("Main Thread ending");
    }
   }

   class WorkerThread extends Thread {

    boolean isDeamon;

    public WorkerThread(boolean isDeamon) {
        // When false, (i.e. when it's a user thread),
        // the Worker thread continues to run.
        // When true, (i.e. when it's a daemon thread),
        // the Worker thread terminates when the main
        // thread terminates.
        this.isDeamon = isDeamon;
        setDaemon(isDeamon);
    }

    public void run() {
        System.out.println("I am a " + (isDeamon ? "Deamon Thread" : "User Thread (none-deamon)"));

        int counter = 0;

        while (counter < 10) {
            counter++;
            System.out.println("\tworking from Worker thread " + counter++);

            try {
                sleep(5000);
            } catch (InterruptedException e) {
                // handle exception here
            }
        }
        System.out.println("\tWorker thread ends. ");
    }
}



result when setDeamon(true)
=====================================
I am a Deamon Thread
    working from Worker thread 0
    working from Worker thread 1
Main Thread ending

Process finished with exit code 0


result when setDeamon(false)
=====================================
I am a User Thread (none-deamon)
    working from Worker thread 0
    working from Worker thread 1
Main Thread ending
    working from Worker thread 2
    working from Worker thread 3
    working from Worker thread 4
    working from Worker thread 5
    working from Worker thread 6
    working from Worker thread 7
    working from Worker thread 8
    working from Worker thread 9
    Worker thread ends. 

Process finished with exit code 0

Questions:
Answers:

Daemon threads die when the creator thread exits.

Non-daemon threads (default) can even live longer than the main thread.

if ( threadShouldDieOnApplicationEnd ) {
    thread.setDaemon ( true );
}
thread.start();

Questions:
Answers:

In Java, Daemon Threads are one of the types of thread which does not prevent Java Virtual Machine (JVM) from exiting.
The main purpose of daemon thread is to execute background task especially in case of some routine periodic task or work. With JVM exits, daemon thread also dies.

By setting a thread.setDaemon(true), a thread becomes a daemon thread. However, you can only set this value before the thread start.