java - 加入不同的工作方式

Question

在这里，我正在学习 java 中的线程，并且偶然发现了 join()。现在，join() 应该让当前线程退出执行，然后下一个线程应该开始。但是，我得到了不同的输出。我的代码是

 public class join extends Thread {
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
            System.out.println(i);
        }
    }
}

class bhago4 
{
    public static void main(String args[]) throws IOException 
{

        join j1 = new join();
        join j2 = new join();
        join j3 = new join();
        j3.start();
        j1.start();
        try {
            j1.join();

        } catch (InterruptedException e) {
            e.printStackTrace();

        }
        j2.start();
    }
}

我得到的输出是:

0
0
1
1
2
2
3
3
4
4
0
1
2
3
4

现在根据我的理解，当 j3 启动时它应该打印 0，然后它 hibernate 500 毫秒，直到 j1 启动，它应该继续直到它结束，但是这并没有发生。两个线程的 o/p 是交替的。为什么会这样？

Answer 1

为了更好地理解输出，更改代码如下

在join类中添加构造函数

 public join(String name){
    super(name);
 }

将打印语句更改为

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

更改线程创建如下:

join j1 = new join("j1");
join j2 = new join("j2");
join j3 = new join("j3");

输出:

0 from j3
0 from j1
1 from j3
1 from j1
2 from j3
2 from j1
3 from j3
3 from j1
4 from j3
4 from j1
0 from j2
1 from j2
2 from j2
3 from j2
4 from j2

join()允许线程死亡。

顺序:

1. j3 开始了。睡了 500 毫秒并打印了 0。
2. j1 并行启动。 sleep 500 毫秒并打印 0。如果将 sleep 时间从 500 毫秒更改为 50 毫秒，则输出在 j1 和j3，并行运行。
3. 两者并行运行并在 1、2、3、4 之后打印， hibernate 时间为 500 毫秒。
4. 通过调用 join()，您正在等待 j1 结束。
5. 你在j1 死后开始了j2。 j3 到那时已经完成。