浅谈Java线程启动与Thread.join()

java中线程的启动有两种方式：

Java代码  

1. class T extends Thread{  
2.     String name;  
3.     public T(String n){  
4.         name=n;  
5.     }  
6.     public void run() {  
7.         try {  
8.             for (int i = 0; i < 2; i++) {  
9.                 System.out.println("-------"+name);  
10.             }  
11.         } catch (Exception e) {}  
12.     }  
13. }  
14. class T1 implements Runnable{  
15.     String name;  
16.     public T1(String n){  
17.         name=n;  
18.     }  
19.     @Override  
20.     public void run() {  
21.         try {  
22.             for (int i = 0; i < 2; i++) {  
23.                 System.out.println("-------"+name);  
24.             }  
25.         } catch (Exception e) {}  
26.     }  
27. }  
28. 启动：  
29. public class Join_Thread {  
30.     public static void main(String[] args) {  
31.         T j1=new T("J1");  
32.         j1.start();  
33.         Thread t3=new Thread(new T1("T_Runable"));  
34.         t3.start();  
35.         System.out.println("Thred End!!");  
36.     }  
37. }  

java中的join方法：

Java代码  

1. public class Join_Thread {  
2.     public static void main(String[] args) {  
3.         T j1=new T("J1");  
4.         j1.start();  
5.         try {  
6.             j1.join();  
7.         } catch (Exception e) {}  
8.         T j2=new T("J2");  
9.         j2.start();  
10.         try {  
11.             j2.join();  
12.         } catch (Exception e) { }  
13.         System.out.println("Join Thred End!!");  
14.     }  
15. }  
16. join();//等待该线程终止。   
17. join(long millis);//等待该线程终止的时间最长为 millis 毫秒。  
18. join(long millis,int nanos);//等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。  

当使用join(long millis)时相当于在主线程中只能等待这么多时间，超过时则继续主线程的函数流程，一直到等到线程苏醒，然后继续线程的运行。
借鉴一个网友的解释：
比如：你准备洗澡，需要准备的步骤，准备好衣服，沐浴的东西及烧水这些事情，由于烧水耗时太长，如果也放在主线程之中，就很浪费资源，所以如果我们另开线程去处理，就会达到很好效果，于是乎在准备好衣服，沐浴的东西之前就去开子线程烧水，烧水的过程中主线程准备好衣服，沐浴的东西，此时就等待水烧好，然后方可痛快的洗澡了！！