What is a daemon thread in Java?

user_236586 0
Viewed 519657

Can anybody tell me what daemon threads are in Java?

multithreading java
26 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.

user_2385780

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

  • When a new thread is created it inherits the daemon status of its parent.

  • When all non-daemon threads finish, the JVM halts, and 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.

user_582200

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 non daemon thread),
        // the WorkerThread continues to run.
        // When true, (i.e. when it's a daemon thread),
        // the WorkerThread terminates when the main 
        // thread or/and user defined thread(non daemon) 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
            }
        }
    }
}
user_12582750

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.

cletus_183930

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 daemon 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 daemon one by using setDaemon method, they usually don't exit, neither they are interrupted.. they just stop when application stops.

user_1217470

Here is an example to test behavior of daemon threads in case of jvm exit due to non existence of user threads.

Please note second last line in the output below, when main thread exited, daemon thread also died and did not print finally executed9 statement within finally block. This means that any i/o resources closed within finally block of a daemon thread will not be closed if JVM exits due to non existence of user threads.

public class DeamonTreadExample {

public static void main(String[] args) throws InterruptedException {

    Thread t = new Thread(() -> {
        int count = 0;
        while (true) {
            count++;
            try {
                System.out.println("inside try"+ count);
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                System.out.println("finally executed"+ count);
            }
        }
    });
    t.setDaemon(true);
    t.start();

    Thread.currentThread().sleep(10000);
    System.out.println("main thread exited");
  }
}

Output

inside try1
finally executed1
inside try2
finally executed2
inside try3
finally executed3
inside try4
finally executed4
inside try5
finally executed5
inside try6
finally executed6
inside try7
finally executed7
inside try8
finally executed8
inside try9
finally executed9
inside try10
main thread exited
user_16474650

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
user_19852340

There already are numerous answers; however, maybe I could shed a bit clearer light on this, as when I was reading about Daemon Threads, initially, I had a feeling, that I understood it well; however, after playing with it and debugged a bit, I observed a strange (to me) behaviour.

I was taught, that:

If I want the thread to die right after the main thread orderly finishes its execution, I should set it as Diamond.

What I tried:

  • I created two threads from the Main Thread, and I only set one of those as a diamond;
  • After orderly completing execution of the Main Thread, none of those newly created threads exited, but I expected, that Daemon thread should have been exited;
  • I surfed over many blogs and articles, and the best and clearest definition I found so far, comes from the Java Concurrency In Practice book, which very clearly states, that:

7.4.2 Daemon threads

Sometimes you want to create a thread that performs some helper function but you don’t want the existence of this thread to prevent the JVM from shutting down. This is what daemon threads are for. Threads are divided into two types: normal threads and daemon threads. When the JVM starts up, all the threads it creates (such as garbage collector and other housekeeping threads) are daemon threads, except the main thread. When a new thread is created, it inherits the daemon status of the thread that created it, so by default any threads created by the main thread are also normal threads. Normal threads and daemon threads differ only in what happens when they exit. When a thread exits, the JVM performs an inventory of running threads, and if the only threads that are left are daemon threads, it initiates an orderly shutdown. When the JVM halts, any remaining daemon threads are abandoned— finally blocks are not executed, stacks are not unwound—the JVM just exits. Daemon threads should be used sparingly—few processing activities can be safely abandoned at any time with no cleanup. In particular, it is dangerous to use daemon threads for tasks that might perform any sort of I/O. Daemon threads are best saved for “housekeeping” tasks, such as a background thread that periodically removes expired entries from an in-memory cache.

user_15535370
  • Daemon threads are those threads which provide general services for user threads (Example : clean up services - garbage collector)
  • Daemon threads are running all the time until kill by the JVM
  • Daemon Threads are treated differently than User Thread when JVM terminates , finally blocks are not called JVM just exits
  • JVM doesn't terminates unless all the user threads terminate. JVM terminates if all user threads are dies
  • JVM doesn't wait for any daemon thread to finish before existing and finally blocks are not called
  • If all user threads dies JVM kills all the daemon threads before stops
  • When all user threads have terminated, daemon threads can also be terminated and the main program terminates
  • setDaemon() method must be called before the thread's start() method is invoked
  • Once a thread has started executing its daemon status cannot be changed
  • To determine if a thread is a daemon thread, use the accessor method isDaemon()
user_108957270

Java daemon thread

[Daemon process]

Java uses user thread and daemon tread concepts.

JVM flow

1. If there are no `user treads` JVM starts terminating the program
2. JVM terminates all `daemon threads` automatically without waiting when they are done
3. JVM is shutdown

As you see daemon tread is a service thread for user treads.

  • daemon tread is low priority thread.
  • Thread inherits it's properties from parent thread. To set it externally you can use setDaemon() method before starting it or check it via isDaemon()
user_47708770

Daemon Thread

Threads that run in the background are called daemon threads.

Example of Daemon Threads:

  1. Garbage Collector.
  2. Signal Dispatcher.

Objective of Daemon Thread:

The main objective of the daemon threads is to provide support to the non-daemon threads.

Additional information about Daemon Thread:

  1. Generally, Daemon threads run in the MIN_PRIORITY however, it is possible to run daemon threads with MAX_PRIORITY as well.

    Example: Usually the GC runs with a MIN_PRIORITY priority, however, once there is a requirement for additional memory. JVM increases the priority of the GC from MIN_PRIORITY to MAX_PRIORITY.

  1. Once the Thread has been started, it can't be changed from Daemon Thread to Non-Daemon Thread that will result in IllegalThreadStateException.

    Example:

    public static void main(String[] args) {
    Thread.currentThread().setDaemon(true);
}

    Output:

    Exception in thread "main" java.lang.IllegalThreadStateException
    at java.base/java.lang.Thread.setDaemon(Thread.java:1403)

  1. If we are branching off a thread, the child thread inherits the nature of the parent thread. If the parent thread is a non-daemon thread automatically the child thread will be non-daemon as well and if the parent thread is a daemon, the child thread will be a daemon as well.

    class Scratch {
    public static void main(String[] args) {
        CustomThread customThread = new CustomThread();
        customThread.start();
    }
}
class CustomThread extends Thread{
    @Override
    public void run() {
        System.out.println(currentThread().isDaemon());
    }
}

    Output:

     false

  1. When the last non-daemon thread terminates, all the daemon threads get terminated automatically.

    class Scratch {
    public static void main(String[] args) {
        System.out.println("Main Thread Started.");

        CustomThread customThread = new CustomThread();
        customThread.setDaemon(true);
        customThread.start();

        System.out.println("Main Thread Finished.");
    }
}
class CustomThread extends Thread{
    @Override
    public void run() {
        System.out.println("Custom Thread Started.");
        try {
            sleep(2000);
        } catch (InterruptedException ignore) {}
        System.out.println("Custom Thread Finished.");  //Won't get executed.
    }
}

    Output:

    Main Thread Started.
Main Thread Finished.
Custom Thread Started.
user_60731480
Related