【20】java多线程之join与yield

先说说join的用法， 在某些情况下，如果子线程里要进行大量的耗时的运算，主线程可能会在子线程执行完之前结束，但是如果主线程又需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()。

1. class Thread1 extends Thread  
2. {  
3.     public Thread1()  
4.     {  
5.         super("[Thread1] Thread");  
6.     }  
7.     public void run()  
8.     {  
9.         String threadName = Thread.currentThread().getName();  
10.         System.out.println(threadName + " start.");  
11.         try   
12.         {  
13.             for(int i = 0; i < 5; i++)  
14.             {  
15.                 System.out.println(threadName + " loop at " + i);  
16.                 Thread.sleep(1000);  
17.             }  
18.             System.out.println(threadName + " end.");  
19.         }   
20.         catch (Exception e)   
21.         {  
22.             System.out.println("exception from " + threadName + ".run");  
23.         }          
24.           
25.     }  
26. }  
27.   
28. class Thread2 extends Thread  
29. {  
30.     Thread1 t1;  
31.     public Thread2(Thread1 thread1)  
32.     {  
33.         super("[Thread2] Thread");  
34.         this.t1 = thread1;  
35.     }  
36.     public void run()  
37.     {  
38.         String threadName = Thread.currentThread().getName();  
39.         System.out.println(threadName + " start.");  
40.         try   
41.         {  
42.             t1.join();  
43.             System.out.println(threadName + " end.");  
44.         }   
45.         catch (Exception e)   
46.         {  
47.             System.out.println("exception from" + threadName + ".run");  
48.         }          
49.           
50.     }  
51. }  
52.   
53.   
54. public class JoinAndYieldTestDemo   
55. {  
56.   
57.     /** 
58.      * @param args 
59.      */  
60.     public static void main(String[] args)   
61.     {  
62.   
63.         String threadName = Thread.currentThread().getName();  
64.         System.out.println(threadName + " start.");  
65.         Thread1 t1 = new Thread1();  
66.         Thread2 t2 = new Thread2(t1);  
67.         try   
68.         {  
69.             t1.start();  
70.             Thread.sleep(2000);  
71.             t2.start();  
72.             t2.join();  
73.         } catch (Exception e)   
74.         {  
75.             System.out.println("exception from main");  
76.         }  
77.           
78.         System.out.println(threadName + " end.");  
79.       
80.     }  
81.   
82. }  

 

1. main start.    //主线程起动   
2. [Thread1] Thread start.    
3. [Thread1] Thread loop at 0    
4. [Thread1] Thread loop at 1    
5. [Thread2] Thread start.       
6. [Thread1] Thread loop at 2    
7. [Thread1] Thread loop at 3    
8. [Thread1] Thread loop at 4    
9. [Thread1] Thread end.    
10. [Thread2] Thread end.        
11. main end!        

从运行结果分析，t2一定在t1之后才结束，main线程则一定在t2结束之后结束，这都要归功于各自调用的join方法。

再来说说yield，建议先看看前一篇文章，关于线程优先级,
http://blog.csdn.net/pony_maggie/article/details/43889225

理论上虚拟机和操作系统会让优先级高的的线程更多的获取执行的机会，这个不要与时间片混淆。yield的意思是放手，放弃，一个线程调用yield意味着它要告诉虚拟机自己乐意让其它线程占用自己的位置。这只是一个暗示，并不保证会产生效果(使当前线程转到可运行状态，runnable)。

看代码示例，

1. class Producer extends Thread  
2. {  
3.     public void run()  
4.     {  
5.         for(int i = 0; i < 5; i++)  
6.         {  
7.             System.out.println("i am producer: producerd item " + i);  
8.             Thread.yield();  
9.         }  
10.     }  
11. }  
12.   
13. class Consumer extends Thread  
14. {  
15.     public void run()  
16.     {  
17.         for(int i = 0; i < 5; i++)  
18.         {  
19.             System.out.println("i am Consumer: Consumed item " + i);  
20.             Thread.yield();  
21.         }  
22.     }  
23. }  
24. public class JoinAndYieldTestDemo   
25. {  
26.   
27.     /** 
28.      * @param args 
29.      */  
30.     public static void main(String[] args)   
31.     {  
32.           
33.         Thread producer = new Producer();  
34.         Thread consumer = new Consumer();  
35.           
36.         producer.setPriority(Thread.MIN_PRIORITY);  
37.         consumer.setPriority(Thread.MAX_PRIORITY);  
38.           
39.         producer.start();  
40.         consumer.start();  
41.     }  
42.   
43. }  

       程序创建了名为生产者和消费者的两个线程，前者最小优先级，后者最大优先级。调用yield方法，两个线程会依次打印，然后将执行机会交给对方，一直这样进行下去。如果不加yield，结果是先打印完一个，再是另一个。

        yield的作用一目了然，设置成不同的优先级，也证明了yield不会受优先级大小的影响。程序中的yield()函数简单说几句，其实和sleep功能相似，都是把当前线程暂停，这样其它线程才能有机会执行。区别就是它没有参数，不能像sleep那样指定暂停的时间。还有个区别很重要，yield只能让同级别优先级的线程得到执行机会。sleep不分优先级，只有当前线程sleep了，其它线程就有机会执行。否则没有sleep的话，只能等高优先级执行完毕，才能执行低优先级的线程。

        说了这么多，似乎并没有说到daemon线程的优点，哪些情况要用到它呢？举个例子，比如垃圾回收线程，我们希望用户线程存在时，它也存在，但当所有的用户线程退出时，程序就要退出，垃圾回收线程不要影响退出。如果定义成了用户线程，那么只要垃圾回收线程不退出，用户线程就不会退出，与实际需求不相符