What's going on in this program, and, more importantly, why?

Question

Please help me understand this program's execution and what concepts apply here in the larger sense? An illustration which explains thread(s)/stack(s) creations and destruction would be helpful.

class Joining {

    static Thread createThread(final int i, final Thread t1) {
        Thread t2 = new Thread() {
            public void run() {
                System.out.println(i+1);
                try {
                    t1.join(); 
                } catch (InterruptedException ie) {
                }
                System.out.println(i+2);
            }
        };
        System.out.println(i+3);
        t2.start(); //1
        System.out.println(i+4);
        return t2;
    }
    public static void main(String[] args) {
        createThread(10, createThread(20, Thread.currentThread()));
    }
}

Answer 1

Hmm...seems to me like the t1.join will hang forever on the first createThread(20, Thread.currentThread)) call.

Answer 2

1. The inner createThread call is called at the bottom from the main thread [M], with the arguments 20 and the current thread.
2. This call prints 23.
3. A new thread [A] is started (and will be returned) which prints 21, and waits for the main thread [M] to die (and will print 22 after it does).
4. This call prints 24. It's impossible to know if this will happen before the new thread [A] prints 21.
5. This call returns the new thread [A], which is waiting for the main thread [M] to die.
6. The new thread [A] is passed as the second argument to the createThread call with 10 as the first argument.
7. This call prints 13.
8. Another new thread [B] is started (and will be returned although nobody is catching this return) which prints 11, and waits for the first created thread [A] to die (and will print 12 after it does).
9. This call prints 14. It's impossible to know if this will happen before this second new thread [B] prints 11.
10. This call returns the second new thread [B], which is waiting for the first created thread [A] to die, but nothing is being done with this return call.
11. The main thread [M] runs out of things to do and dies.
12. When the main thread [M] dies, the join() call on the first created thread [A] returns.
13. The first created thread [A] prints 22.
14. The first created thread [A] dies.
15. When the first created thread [A] dies, the join() call on the second created thread [B] returns.
16. The second created thread [B] prints 12.
17. The second created thread [B] dies.
18. The JVM shuts down, because all threads have died.

Answer 3

Adding some debug-output will probably help you understand the execution:

import static java.lang.Thread.currentThread;

class Joining {

    static int count = 0;

    static Thread createThread(final int i, final Thread t1) {
        System.out.println("Create thread with " + i + " and " + t1.getName());
        Thread t2 = new Thread("Thread " + count++) {
            public void run() {
                System.out.println(currentThread().getName() + ": " + (i+1));
                try {
                    System.out.println(currentThread().getName() + ": join with " + t1.getName());
                    t1.join(); 
                } catch (InterruptedException ie) {
                }
                System.out.println(currentThread().getName() + ": " + (i+2));
            }
        };
        System.out.println(currentThread().getName() + ": " + (i+3));
        System.out.println(currentThread().getName() + ": starting thread " + t2.getName());
        t2.start(); //1
        System.out.println(currentThread().getName() + ": " + (i+4));
        return t2;
    }

    public static void main(String[] args) throws InterruptedException {
        Thread someThread = createThread(20, currentThread());
        System.out.println("After first createThread.");
        Thread.sleep(1000);
        createThread(10, someThread);
    }
}

The output is

Create thread with 20 and main
main: 23
main: starting thread Thread 0
main: 24
After first createThread.
Thread 0: 21
Thread 0: join with main
Create thread with 10 and Thread 0
main: 13
main: starting thread Thread 1
main: 14
Thread 1: 11
Thread 1: join with Thread 0
Thread 0: 22
Thread 1: 12