这个线程加入代码是什么意思？

Question

在这段代码中,两者的连接和分解意味着什么？t1.join()导致t2停止直到t1终止？

Thread t1 = new Thread(new EventThread("e1"));
t1.start();
Thread t2 = new Thread(new EventThread("e2"));
t2.start();
while (true) {
   try {
      t1.join();
      t2.join();
      break;
   } catch (InterruptedException e) {
      e.printStackTrace();
   }
}

Answer 1

引用Thread.join()javadocs方法:

join() 等待这个线程死亡.

有一个运行您的示例代码的线程可能是主线程.

1. 主线程创建并启动t1和t2线程.两个线程并行开始运行.
2. 主线程调用t1.join()等待t1线程完成.
3. 该t1线程完成和t1.join()方法在主线程返回.请注意,t1在join()调用之前可能已经完成,在这种情况下,join()调用将立即返回.
4. 主线程调用t2.join()等待t2线程完成.
5. 该t2线程完成(或者它可能已经完成了前t1线程那样)和t2.join()方法在主线程返回.

重要的是要理解t1和t2线程并行运行,但启动它们的主线程需要等待它们才能继续运行.这是一种常见的模式.此外,t1和/或t2可能在主线程调用它们之前完成join().如果是这样,那么join()不会等待,但会立即返回.

t1.join() 意味着导致t2停止直到t1终止？

否.正在调用的主线程t1.join()将停止运行并等待t1线程完成.该t2线程并行运行,而不是受影响t1或t1.join()电话都没有.

就try/catch而言,join()throws InterruptedException意味着调用的主线程join()本身可能被另一个线程中断.

while (true) {

将while循环连接成一个奇怪的模式.通常,您将执行第一次连接,然后InterruptedException在每种情况下执行第二次连接.无需将它们放在循环中.

Answer 2

这是一个最受欢迎的Java面试问题.

Thread t1 = new Thread(new EventThread("e1"));
t1.start();
Thread e2 = new Thread(new EventThread("e2"));
t2.start();

while (true) {
    try {
        t1.join(); // 1
        t2.join(); // 2  These lines (1,2) are in in public static void main
        break;
    }
}

t1.join()意思是,t1说的是" 我想先完成 ".情况也是如此t2.无论是谁开始t1或t2线程(在这种情况下是main方法),main都会等到t1并t2完成他们的任务.

然而,重要的一点要注意了,t1并且t2自己可以并行而不考虑加入调用序列的运行 上t1和t2.这是main/daemon必须等待的线程.

Answer 3

join()意味着等待线程完成.这是一种阻止方法.您的主线程(执行该线程的线程join())将在线上等待t1.join()直到t1完成其工作,然后将执行相同的操作t2.join().

Answer 4

一张图片胜过千言万语.

    Main thread-->----->--->-->--block##########continue--->---->
                 \                 |               |
sub thread start()\                | join()        |
                   \               |               |
                    ---sub thread----->--->--->--finish    

希望有用,更多细节点击这里

Answer 5

当线程tA调用tB.join()时,它的原因不仅等待tB死亡或者tA自身中断,而且创建发生 - 在tB中的最后一个语句与tA线程中的tB.join()之后的下一个语句之间的关系.

线程中的所有操作都发生在任何其他线程从该线程上的join()成功返回之前.

这意味着程序

class App {
    // shared, not synchronized variable = bad practice
    static int sharedVar = 0;
    public static void main(String[] args) throws Exception {
        Thread threadB = new Thread(() -> {sharedVar = 1;});
        threadB.start();
        threadB.join();

        while (true) 
            System.out.print(sharedVar);
    }
}

始终打印

>> 1111111111111111111111111 ...

但程序

class App {
    // shared, not synchronized variable = bad practice
    static int sharedVar = 0;
    public static void main(String[] args) throws Exception {
        Thread threadB = new Thread(() -> {sharedVar = 1;});
        threadB.start();
        // threadB.join();  COMMENT JOIN

        while (true)
            System.out.print(sharedVar);
    }
}

不仅可以打印

>> 0000000000 ... 000000111111111111111111111111 ...

但

>> 00000000000000000000000000000000000000000000 ... 

始终只有'0'.

因为Java内存模型不需要将'sharedVar'的新值从threadB'转移'到主线程而没有heppens-before关系(线程启动,线程连接,'synchonized'关键字的使用,AtomicXXX变量的使用等).

Answer 6

简单地说：完成
t1.join()后返回t1。
它不会对 thread 做任何事情t1，除了等待它完成。
当然，后面的代码 t1.join()只有在t1.join()返回后才会执行 。