1. 
   

复制代码

1. public class Test_Join {
   
2.         /**
   
3.          * @param args
   
4.          */
   
5.         public static void main(String[] args) {
   
6.                 JoinMethod j=new JoinMethod();
   
7.                 Thread a=new Thread(j,"线程A");
   
8.                 Thread b=new Thread(j,"线程B");
   
9.                 Thread c=new Thread(j,"线程c");
   
10.                 a.start();
    
11.                 b.start();
    
12.                 c.start();
    
13.                 try {
    
14.                         Thread.sleep(2000);
    
15.                 } catch (InterruptedException e1) {
    
16.                         // TODO Auto-generated catch block
    
17.                         e1.printStackTrace();
    
18.                 }
    
19.                 System.out.println("======================");
    
20.                 System.out.println(c.isAlive());
    
21.                 for (int i = 0; i < 10; i++) {
    
22.                         try {
    
23.                                 c.join();
    
24.                         } catch (InterruptedException e) {
    
25.                                 // TODO Auto-generated catch block
    
26.                                 e.printStackTrace();
    
27.                         }
    
28.                 }
    
29.         }        
    
30. }
    
31. class JoinMethod implements Runnable{
    
32.         public void run(){
    
33.                 for (int i = 0; i <10; i++) {
    
34.                         System.out.println(Thread.currentThread().getName());
    
35.                 }
    
36.         }
    
37. }
    

复制代码

先不说这种极端方法的合理性，线程都运行完了，再使用join,为什么捕获异常这里没有一个关于线程死亡的异常呢？

开启abc线程后，sleep()方法让主线程睡觉了。。。然后abc就欢快的跑~~
等到主线程醒了 abc也跑完了。。。结束run()方法的abc进程都死亡了。
判断c.isAlive();结果自然也是false

感觉应该是 既然c进程都死亡了
c.join 就成了无用的代码（？）

我就是这个疑问，这个应该设计一个线程死亡的异常