Java 加入不同的工作

在这里，我在学习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();
    }
}

---

现在根据我的理解，当j3开始时，它应该打印0，然后它休眠500毫秒，直到j1开始，它应该一直持续到它的结束，但这并没有发生。两个螺纹的o/p是交替的。为什么会发生这种情况？

当您运行

j3.start（）

和

j1.start（）

时，您正在创建理论上同时运行的两个CPU线程；因此，

001122..44

的输出工作正常

当join runnable启动时，它首先等待500毫秒，然后打印一个数字

1和3同时启动，但您告诉主要威胁等待j1结束。与此同时，j3也在印刷。因此，您正在重新生成输出上的重复数字

完成j1后，存在

join（）

lock，j2启动，但随后到达程序末尾。有时它可能无法及时完成

如果您想更好地了解正在发生的事情，请为每个线程添加一个名称，如：

public class Join extends Thread {
   private final String name;

    public Join(String name){ this.name=name; }
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
            System.out.println(name+": "+i);
        }
    }
}

公共类联接扩展线程{
私有最终字符串名；
公共联接（字符串名）{this.name=name；}
公开募捐{
对于（int i=0；i<5；i++）{
试一试{
睡眠（500）；
}捕捉（中断异常e）{
系统输出打印ln（e）；
}
System.out.println（name+“：”+i）；
}
}
}

---

您可以使用教程，它看起来非常类似于您的示例

，要更好地理解输出，请更改代码如下

在

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

允许线程死亡

顺序：

j3已启动。睡眠500毫秒，打印0

j1并联启动。睡眠500毫秒，打印0。如果将睡眠时间从500ms更改为50ms，则在并行运行的j1和j3之间的输出是不可预测的

两者都并行运行，并在1,2,3,4之后打印，睡眠时间为500毫秒

通过调用join（），您正在等待j1死亡

您在j1死亡后开始j2j3到那时已经完成

---

但是join（）意味着，另一个线程（j3）将等待，直到放置join的线程（j1）结束……这就是我遇到的问题。谢谢，我现在明白了，尽管我的问题很愚蠢。谢谢你的解释。

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