Thread中的join sleep yield wait notify方法的使用

1.首先来说说线程Thread的Join方法：

join方法顾名思义 就是往线程中添加东西的；join方法可以用于临时加入线程，一个线程在运算过程中，如果满足于条件，我们可以临时加入一个线程，让这个线程运算完，另外一个线程再继续运行。

看一下一个demo：

[java]  view plain  copy

1. /** 
2.  * join方法可以用于临时加入线程，一个线程在运算过程中，如果满足于条件， 
3.  * 我们可以临时加入一个线程，让这个线程运算完，另外一个线程再继续运行。 
4.  * @author leo-zeng 
5.  * 
6.  */  
7. public class JoinTest {  
8.     public static void main(String[] args) throws Exception {  
9.         ThreadTest test  =new ThreadTest();  
10.         ThreadTest test2  =new ThreadTest();  
11.         test.setName("one");  
12.         test2.setName("two");  
13.         Thread t1 = new Thread(test);  
14.         Thread t2 = new Thread(test2);  
15.         t1.start();  
16.         /** 
17.          * 主线程向下转时，碰到了t1.join(),t1要申请加入到运行中来，就是要CPU执行权。 
18.          * 这时候CPU执行权在主线程手里，主线程就把CPU执行权给放开，陷入冻结状态。 
19.          * 活着的只有t1了，只有当t1拿着执行权把这些数据都打印完了，主线程才恢复到运行中来 
20.          */  
21.         //join 方法 确保 t1执行之后 执行t2  
22.         t1.join();  
23.         t2.start();  
24.           
25.     }  
26. }  
27. class ThreadTest implements Runnable{  
28.       
29.     private String name;  
30.       
31.     public void setName(String name) {  
32.         this.name = name;  
33.     }  
34.     public String getName() {  
35.         return name;  
36.     }  
37.     @Override  
38.     public void run() {  
39.         for (int i = 0; i < 5; i++) {  
40.                 System.out.println(this.getName()+"------"+i);  
41.         }  
42.     }  
43.       
44. }  

运行结果：

one------0
one------1
one------2
one------3
one------4
two------0
two------1
two------2
two------3
two------4

主线程向下转时，碰到了t1.join(),t1要申请加入到运行中来，就是要CPU执行权。这时候CPU执行权在主线程手里，主线程就把CPU执行权给放开，陷入冻结状态。 活着的只有t1了，只有当t1拿着执行权把这些数据都打印完了，主线程才恢复到运行中来；这就是调用join方法的用法。

2.看下sleep、yield方法：

Thread.yield()方法暂停当前正在执行的线程对象，并执行其他线程。也就是交出CPU一段时间(其他同样的优先级或者更高优先级的线程可以获取到运行的机会)；不会释放锁资源。

而Thread.sleep()方法使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行, 同时sleep函数不会释放锁资源；sleep可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会。

这两个的区别在于yield只能是同级，或者高级优先执行，而sleep可以低级，同级都可以有优先执行机会。

看以下两个demo

[java]  view plain  copy

1. public class YieldTest {  
2.       
3.     public static void main(String[] args) {  
4.         ThreadTest2 test1 = new ThreadTest2();  
5.         test1.setName("one");  
6.         ThreadTest2 test2 = new ThreadTest2();  
7.         test2.setName("two");  
8.         Thread t1 =new Thread(test1);  
9.         Thread t2 =new Thread(test2);  
10.         t1.setPriority(Thread.MAX_PRIORITY);  
11.         t2.setPriority(Thread.MIN_PRIORITY);  
12.         t1.start();  
13.         t2.start();       
14.     }  
15. }  
16. class ThreadTest2 implements Runnable{  
17.       
18.     private String name;  
19.       
20.     public void setName(String name) {  
21.         this.name = name;  
22.     }  
23.     public String getName() {  
24.         return name;  
25.     }  
26.       
27.     @Override  
28.     public void run() {  
29.           
30.         for (int i = 0; i <10; i++) {  
31.             Thread.yield();  
32.             System.out.println(this.getName()+"------"+i);  
33.         };  
34.           
35.     }  
36.       
37. }  

如果不用yield()方法的话，两个线程应该是交替进行的，用了yield（）之后，cpu会多交出一些时间给ti优先执行。

[java]  view plain  copy

1.  */  
2. public class SleepTest {  
3.     public static void main(String[] args) {  
4.         ThreadTest3 test2 = new ThreadTest3();  
5.         ThreadTest3 test3 = new ThreadTest3();  
6.         Thread t1 =new Thread(test2);  
7.         Thread t2 =new Thread(test3);  
8.             t1.setPriority(Thread.MAX_PRIORITY);//设置最高级别  
9.             t2.setPriority(Thread.MIN_PRIORITY);//设置最低级别  
10.             t1.start();  
11.             t2.start();       
12.     }  
13. }  
14.   
15. class ThreadTest3 implements Runnable{  
16.   
17.     @Override  
18.     public void run() {  
19.           
20.         for (int i = 0; i <10; i++) {  
21.             try {  
22.                 Thread.sleep(100);  
23.                 System.out.println(Thread.currentThread().getName()+"------"+i);  
24.             } catch (InterruptedException e) {  
25.                   
26.                 e.printStackTrace();  
27.             }  
28.               
29.         };  
30.           
31.     }  
32. }  

使用sleep的话，随机性就大一些。

3.wait()，notify()方法

顺便说下Object 类的wait()方法和notify()方法，注意这个不是Thread类的方法；还有这两个方法主要是操作锁标志的，所以只能在synchronized方法或者synchronized block中

使用；wait()方法在睡眠的时候会放开锁，给其他的线程使用。wait()有两种方式获得锁：1.wait(longtimeout),通过设定时间来获得锁，值得注意的是，timeout这个时间到了以后，它不会立即醒来，而是要看那个正在使用这把锁的线程是否结束。2.通过notify()的方法，通知需要这把锁的wait()，使之唤醒，还有wait 方法也要和sleep方法区别，上面说到sleep方法是不释放锁资源的。

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Leonardo9029/article/details/46343289

想对作者说点什么？  我来说一句

• 
  史文天WildTurtle 2018-01-19 18:33:05 #4楼

  join方法不就是等待线程结束吗？你这个博客写来写去写半天，自己不累啊

  查看回复(1)

• 
  qiangju9473 2018-01-13 15:53:38 #3楼

  感觉lz对join方法的理解有偏差。还是希望看看其他人的blog,综合一下。

  查看回复(1)

• 
  sunqichang2012 2017-10-18 18:35:21 #2楼

  碰到了t1.join(),t1要申请加入到运行中来，就是要CPU执行权 --&gt; 你确定这句话正确？

  查看回复(1)

• 
  baidu_36822926 2016-11-25 20:35:16 #1楼

  太好啦写的

查看 7 条热评

Java中的线程Thread方法之---join()

上一篇我们说到了Thread中的stop方法，这一篇我们再来看一下方法join的使用，那么方法Join是干啥用的？ 简单回答，同步，如何同步？ 怎么实现的？ 下面将逐个回答。 join方法从字...

 jiangwei0910410003

2014-02-25 13:38:22

阅读数：9288

thread中join和detach的区别

C++中的thread对象通常来说表达了执行的线程（thread of execution），这是一个OS或者平台的概念。 当thread::join()函数被调用，调用它的线程会被block，直到线...

 xibeichengf

2017-05-04 19:11:27

阅读数：7581

java中Thread类的join方法 - CSDN博客

单核cpu运行多线程时底层实现原理是多个线程间切换,由于cpu的处理速度很快,看上去像多个线程同时运行。那么我们如何实现让线程T1,T2,T3,在T1执行完成后才执行T2,...