java - join() 在 Java 中如何工作？能保证在main()之前执行吗？

Question

我正在尝试理解 join() 的代码流。

public class Multi extends Thread {

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {

        Thread t1 = new Multi();
        Thread t2 = new Multi();
        Thread t3 = new Multi();
        Thread t4 = new Multi();

        t1.start();
        try {
            t1.join();
        } catch (Exception e) {
        }

        t2.start();        
        t3.start();
        try {
            t3.join();
        } catch (Exception e) {
        }        
        t4.start();

        System.out.println("........" + Thread.currentThread().getName());

        t1.setName("A");
        t2.setName("B");
        t3.setName("C");
        t4.setName("D");
    }
}

正如我多次运行程序后观察到的那样，输出始终是 thread t1 首先执行，并且它将完成它的执行，而无需任何上下文切换，并且每当 t3 将开始，它将完成它的执行。我的理解清楚吗？

我观察到，如果不使用连接，main() 会在线程执行的任何地方执行，这意味着我看到 .......main 输出在我程序的输出之间，但在 join() 之后它总是在线程 t3 之后执行。这是我的疑问，因为 main() 在 join() 语法之前开始，所以它不应该遵循 t3/t1 线程完成？它有意义还是我遗漏了什么？

Answer 1

简答

How does join() work in java?

我同意你 the javadoc for join()有点不清楚，因为第一次阅读 this 指的是谁并不明显。

这意味着调用t.join() 的线程会阻塞，直到线程t 完成执行。如果当前线程调用t.join()时t已经结束，则当前线程不会停止，继续运行。 文档中的单词 this 在这里指的是 t，而不是调用该方法的线程。

Does it guarantee the execution before main()?

[...] if no join is used, main() executes anywhere b/w the execution of threads [...]

您不应将 main() 视为一个整体。 main() 的一部分在其他线程之前执行，一部分并行执行，一部分在其他线程之后执行。这实际上是 start() 和 join() 控制的。下面我来解释一下。

main() 中发生了什么

这是关于 t1.start() 和 t1.join() 的事件序列。对于 t3，您显然可以采用相同的方式思考。

1. 执行t1.start()之前的main()指令

2. t1.start() 启动线程 t1(t1.run() 可能不会立即启动。)

3. t1.start()和t1.join()之间的main()指令并行执行( *) t1.run() 中的那些。
   注意:您的示例中没有任何指令，因此此时仅执行 t1.run() 指令。

4. t1.join():

   • 如果 t1.run() 已经完成，什么也不会发生，main() 继续运行
   • 如果 t1.run() 尚未完成，主线程将停止并等待直到 t1.run() 完成。然后 t1.run() 完成，然后 main() 恢复。

5. t1.join()执行后main()的指令

在这里你可以看到:

• t1.start() 之前的 main() 部分保证在 t1.run() 之前执行
• t1.join() 之后的 main() 部分保证在 t1.run() 之后执行

(*) 请参阅下面有关并行性的部分

“并行执行”是什么意思

假设您在 2 个线程 A 和 B 中执行了这 2 组指令:

// Thread A                   |     // Thread B
                              | 
System.out.println("A1");     |     System.out.println("B1");
System.out.println("A2");     |     System.out.println("B2");
System.out.println("A3");     |     System.out.println("B3");

如果这 2 个线程“并行执行”，这意味着 3 件事:

• 保证线程A的指令执行顺序:
  A1 在 A2 之前执行，A2 在 A3 之前执行。

• 保证线程B的指令执行顺序:
  B1 在 B2 之前执行，B2 在 B3 之前执行。

• 但是，A 和 B 的指令可以交错，这意味着以下所有情况都是可能的(甚至更多):

A1, B1, A2, B2, B3, A3

B1, B2, A1, B3, A2, A3

A1, A2, A3, B1, B2, B3 // special case where A's are all executed before B's

B1, B2, B3, A1, A2, A3 // special case where B's are all executed before A's

---

注意:本节将并行处理作为操作系统创建的一种错觉，让用户感觉事物同时运行，而实际上只是一个核心按顺序执行指令，从一个进程/线程跳转到另一个。

事实上，A 指令和 B 指令可以在 2 个独立的内核上同时执行(真正的并行性)。无论如何，上面的 3 个要点仍然有效。正如@jameslarge 指出的那样，通常我们使用一系列事件对并发进行建模，即使对于多核也是如此。这忽略了 2 个事件同时发生的概念，它不会带来任何有用的东西，只会带来复杂性。