Why doesn't daemon thread which is joined to the main() thread die when main() thread execution ends?

Question

In the below code:

class Worker extends Thread {
    Thread t;

    public Worker(Thread thread) {
        t=thread;
    }

    public void run() {
        try {
            t.join();
        } catch(InterruptedException e) {
            System.out.println("Exception is thrown and caught");
        }
        System.out.println(Thread.activeCount());
        System.out.print("|work|");
    }

    public static void main(String[] args) {
        Thread t=Thread.currentThread();
        Worker worker = new Worker(t);
        worker.setDaemon(true);
        worker.start();
        System.out.println("Exit from main method");
    }
}

Since worker is a daemon thread joined on main() thread, |work| should never be printed since the user thread main() completes first, and since worker is a daemon thread it too is stopped when the main() thread dies. But, the output I get is as follows : Exit from main method 1 |work|

Please clarify this query for me.

After many many executions of the program, I have observed the following different outputs:

without Thread.sleep(1000) :

Exit from main method 2

Exit from main method 1 |work|

Exit from main method 2 |work|

with Thread.sleep(1000) :

Exit from main method 2 |work|

Exit from main method

Notice the first output without sleep() method. |work| is not printed but the thread count is shown to be 2. Does this mean main() thread execution ended after Thread.activeCount() but before |work| is printed? In third output seems like main() ended after execution of both these statements.

Now, I was never expecting Thread.activeCount() to be 2, since the daemon thread worker is joined on user thread main(), which means when Thread.activeCount() is executed, there will only be worker thread and no main() thread.

I thought the point of daemon threads was that they're safely "cut-loose"; that they aren't required to be joined. — Carcigenicate
No. It did not. The program terminated normally after printing |work| — paidedly
How do you know? With that code, you cannot possibly tell. You have an empty catch block for that exception. — user207421
Your program will exit when all non-daemon threads are done executing. You said t.start() and also a Sysout immediately after. I'd think that your main() exits even before the t.join happens or some sort of scheduling happens which makes your Sysout execute before the join call. Can you execute it a few times ( a lot ) and see what if your behavior changes? Also add a sleep after the t.start() and before the sysout and see what happens? — Praba

JB Nizet JB Nizet · Accepted Answer · 2015-05-04T11:11:09

I don't know the exact details on how the VM knows when the last non-daemon thread stops running, but I can imagine 2 solutions:

a background regularly polls to see if all non-daemon threads have exited (and I doubt that's the actual solution)
a background thread joins on all the non-deamon threads, and exits the VM once all the join return

In those two situations, a race condition is possible, and the daemon thread sometimes has time to execute a few more operations after the main thread has died, and sometimes not.

I executed your code a few times, and sometimes something is printed after the main thread has exited, and sometimes not, which corroborates my theory.

When I add a Thread.sleep(100L) call after t.join(), nothing is printed except "Exit from main method".

Also note that if you look at the list of threads running in the VM (using the debugger for example), one of them is named "DestroyJavaVM". Given the name, I'd guess this is the thread which exits the JVM, concurrently to the remaining daemon threads, once the last non-daemon thread stops running.

Why doesn't daemon thread which is joined to the main() thread die when main() thread execution ends?

3 Answers