該程序中發生了什么，更重要的是，為什么？

Question

請幫助我了解該程序的執行情況，從廣義上講，哪些概念適用於此？ 解釋線程/堆棧的創建和銷毀的圖示可能會有所幫助。

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

1. 內部createThread調用從主線程[M]的底部調用，並帶有參數20和當前線程。
2. 該呼叫打印23。
3. 一個新的線程[A]被啟動（將返回），它打印21，並等待主線程[M]死（在完成后將打印22）。
4. 此調用將打印24。無法知道是否會在新線程[A]打印21之前發生。
5. 該調用返回新線程[A]，該線程正在等待主線程[M]終止。
6. 新線程[A]作為第二個參數傳遞給createThread調用，第一個參數為10。
7. 該呼叫將打印13。
8. 啟動另一個新線程[B]（盡管沒有人捕捉到此返回，但將返回該線程），該線程將打印11，並等待第一個創建的線程[A]死（此后將打印12）。
9. 該調用將打印14。不可能知道是否會在第二個新線程[B]打印11之前發生。
10. 該調用返回第二個新線程[B]，該線程正在等待第一個創建的線程[A]終止，但是此返回調用未執行任何操作。
11. 主線程[M]用盡了所有資源，然后死掉了。
12. 當主線程[M]死時，對第一個創建的線程[A]的join（）調用返回。
13. 創建的第一個線程[A]打印22。
14. 創建的第一個線程[A]死亡。
15. 當第一個創建的線程[A]死亡時，對第二個創建的線程[B]的join（）調用返回。
16. 創建的第二個線程[B]打印12。
17. 創建的第二個線程[B]死亡。
18. JVM關閉，因為所有線程都已死亡。

Answer 2

添加一些調試輸出可能會幫助您理解執行：

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);
    }
}

輸出是

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

Answer 3

嗯...對我來說好像t1.join會永遠掛在第一個createThread（20，Thread.currentThread））調用上。