线程的join方法讲解

Example1：

Java代码  

1. public class JoinTest implements Runnable{  
2.       
3.     public static int a = 0;  
4.   
5.     public void run() {  
6.         for (int k = 0; k < 5; k++) {  
7.             a = a + 1;  
8.         }  
9.     }  
10.   
11.     public static void main(String[] args) throws Exception {  
12.         Runnable r = new JoinTest();  
13.         Thread t = new Thread(r);  
14.         t.start();        
15.         System.out.println(a);  
16.     }         
17. }  

 请 问程序的输出结果是5吗？答案是：有可能。其实你很难遇到输出5的时候，通常情况下都不是5。当然这也和机器有严重的关系。为什么呢？我的解释是当主线程 main方法执行System.out.println(a);这条语句时，线程还没有真正开始运行，或许正在为它分配资源准备运行。因为为线程分配资源需要时间，而main方法执行完t.start()方法后继续往下执行System.out.println(a);,这个时候得到的结果是a还没有被 改变的值0 。怎样才能让输出结果为5！其实很简单，join() 方法提供了这种功能。join() 方法，它能够使调用该方法的线程在此之前执行完毕。

Java代码  

1. public static void main(String[] args) throws Exception {  
2.         Runnable r = new JoinTest();  
3.         Thread t = new Thread(r);  
4.         t.start();        
5.         t.join(); //加入join()  
6.         System.out.println(a);  
7.     }     

 这个时候，程序输入结果始终为5。

为 了证明如果不使用t.join()方法，主线程main方法的System.out.println(a);语句将抢先执行，我们可以在main方法中加入一个循环，这个循环用来延长main方法执行的时间，循环次数将严重取决于机器性能。如果循环次数得当，我们也可以看到a的输出结果是5。

Java代码  

1. public static void main(String[] args) throws Exception {  
2.         Runnable r = new JoinTest();  
3.         Thread t = new Thread(r);  
4.         t.start();        
5.         //t.join(); //加入join()  
6.             /* 
7.              注意循环体内一定要有实际执行语句，否则编译器或JVM可能优化掉你的这段代码，视这段代 
8.              码为无效。             
9.             */  
10.             for (int i=0; i<300; i++) {                
11.                 System.out.print(i);  
12.             }  
13.             System.out.println();  
14.         System.out.println(a);  
15.     }         

 经自己测试，最后a一直是5.

Example2：join(n)

Java代码  

1. class RunnableImpl implements Runnable {  
2.   
3.     public void run() {  
4.         try {  
5.             System.out.println("Begin sleep");  
6.             Thread.sleep(1000);  
7.            System.out.println("End sleep");  
8.         } catch (InterruptedException e) {  
9.             e.printStackTrace();  
10.         }  
11.   
12.     }  
13. }  

 

Java代码  

1. public class JoinTest{  
2.       
3.     public static void main(String[] args) {  
4.         Thread t = new Thread(new RunnableImpl());  
5.         t.start();  
6.         try {  
7.             t.join(1000);  
8.             System.out.println("joinFinish");  
9.         } catch (InterruptedException e) {  
10.             e.printStackTrace();       
11.         }  
12.     }  
13. }  

结果是：
Begin sleep
End sleep
joinFinish

明白了吧，当main线程调用t.join时，main线程等待t线程，等待时间是1000，如果t线程Sleep 2000呢