join合并线程,待此线程执行完成后,在执行其他线程,其他线程阻塞
package thread.lzy.www;
public class dBlockedjoind01 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
for(int i=0;i<10;i++) {
System.out.println("lambda..."+i);
}
}) ;
t.start();
for(int i=0;i<10;i++) {
if(i==4) {
t.join();
}
System.out.println("main.."+i);
}
}
}
代码中当i==4时,lambda插队,直到lambda运行完后,才轮到main函数运行
运行结果:
main…0
main…1
lambda…0
main…2
lambda…1
main…3
lambda…2
lambda…3
lambda…4
lambda…5
lambda…6
lambda…7
lambda…8
lambda…9
main…4
main…5
main…6
main…7
main…8
main…9
实例二:
package thread.lzy.www;
public class dBlockedjoind02 {
public static void main(String[] args) {
System.out.println("爸爸和儿子买烟的故事");
new Thread(new Father()).start();
}
}
class Father extends Thread{
public void run() {
System.out.println("想抽烟,发现没了");
System.out.println("让儿子去买中华");
Thread t=new Thread(new Son());
t.start();
try {
t.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("买烟失败");
}
System.out.println("老爸接过烟,把零钱给了儿子");
}
}
class Son extends Thread{
@Override
public void run() {
System.out.println("儿子接过老爸钱出去了");
System.out.println("路边有个游戏厅,玩了10s");
for(int i=0;i<10;i++) {
System.out.println(i+"秒过去了");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("赶紧买烟去。。。");
System.out.println("拿着烟回家了");
}
}
这是一个老爸让儿子买烟的实例,只有儿子买完烟回来,老爸才能抽,把零钱给儿子,如果没有join(17-23行代码),运行结果:
爸爸和儿子买烟的故事
想抽烟,发现没了
让儿子去买中华
老爸接过烟,把零钱给了儿子
儿子接过老爸钱出去了
路边有个游戏厅,玩了10s
0秒过去了
1秒过去了
2秒过去了
3秒过去了
4秒过去了
5秒过去了
6秒过去了
7秒过去了
8秒过去了
9秒过去了
赶紧买烟去。。。
拿着烟回家了
可以看到,儿子还没有买烟回来,爸爸却接过烟,把零钱给了儿子,很显然不合逻辑,所以在爸爸拿到香烟之前即24行代码(System.out.println("老爸接过烟,把零钱给了儿子");
)前面加入join 让儿子“插队”当15 16行代码即Son执行完后,在执行24行
加入之后运行结果:
爸爸和儿子买烟的故事
想抽烟,发现没了
让儿子去买中华
儿子接过老爸钱出去了
路边有个游戏厅,玩了10s
0秒过去了
1秒过去了
2秒过去了
3秒过去了
4秒过去了
5秒过去了
6秒过去了
7秒过去了
8秒过去了
9秒过去了
赶紧买烟去。。。
拿着烟回家了
老爸接过烟,把零钱给了儿子