线程等待唤醒机制

 

1.1  线程间通信

其实就是多个线程在操作同一个资源，但是操作的动作不同。

比如一个线程给一个变量赋值，而另一个线程打印这个变量。

 

1.2  等待唤醒机制

wait()：将线程等待，释放了CPU执行权，同时将线程对象存储到线程池中。

notify()：唤醒线程池中一个等待的线程，若线程池有多个等待的线程，则任意唤醒一个。

notifyAll()：唤醒线程池中，所有的等待中的线程。

 

这三个方法都要使用在同步中，因为要对持有锁的线程进行操作。

比如，A锁上的线程被wait了，那么这个线程就进入了A锁的线程池中，只能被A锁的notify唤醒，而不能被不同锁的其他线程唤醒。

所以这三个方法要使用在同步中，因为只有同步才具有锁。

而锁可以是任意对象，这三个方法被锁调用，所以这三个方法可以被任意对象调用，所以这三个方法定义在Object类中。

 

wait()和sleep()的区别：

wait()：可以指定等待的时间，也可以不指定时间，如果不指定时间，就只能被同一个锁的notify或notifyAll唤醒。wait时线程会释放CPU执行权，并且会释放锁。

sleep()：必须指定线程休眠的时间，线程休眠即暂停执行。时间到了，线程就自动苏醒，恢复运行。sleep时线程会释放执行权，但不释放锁。

 

线程的停止：

1，如果run()方法中定义了循环，可以用循环结束标记，跳出循环，则线程就停止了。 

2，如果线程已被冻结，读不到循环结束标记，则需要通过Thread类的interrupt方法中断线程，让线程重新获得执行的资格，从而可以读到循环结束标记，而结束线程。

3，setDaemon(true)方法将当前线程标记为守护线程，当运行的线程都是守护线程时，则Java虚拟机退出。该方法必须在启动线程前调用。

 

等待唤醒机制代码，实现两个线程交替执行，在控制台上交替打印两个字符串。

等待和唤醒是同一个锁r：

 

[java] view plaincopy

 

1. //两个线程交替执行，在控制台交替打印两串字符串。  
2. class Res{  
3.     String name;  
4.     String sex;  
5.     boolean flag = false; //等待唤醒机制  
6. }  
7. class Input implements Runnable{  
8.     private Res r;  
9.     Input(Res r){  
10.         this.r = r;  
11.     }  
12.     public void run(){  
13.         int x = 0;  
14.         while(true){  
15.             synchronized(r){  //等待和唤醒，是同一个锁。  
16.                 if(r.flag)    //等待唤醒机制，true则等待，false则执行  
17.                     try{r.wait();}catch(Exception e){}  //线程等待，进入线程池  
18.                 if(x == 0){  
19.                     r.name = "LuoQi";  
20.                     r.sex = "man";  
21.                 }  
22.                 else{  
23.                     r.name = "丽丽";  //赋值时，赋值了name还没赋值sex，就打印“lili----male”,加同步锁，牢记同步前提。  
24.                     r.sex = "女";  
25.                 }  
26.                 x = (x+1)%2;  
27.                 r.flag = true;  //等待唤醒机制  
28.                 r.notify();  //任意唤醒线程池里的一个被等待的线程  //等待唤醒机制  
29.             }  
30.         }  
31.     }  
32. }  
33. class Output implements Runnable{  
34.     private Res r;  
35.     Output(Res r){  
36.         this.r = r;  
37.     }  
38.     public void run(){  
39.         while(true){  
40.             synchronized(r){  //等待和唤醒，是同一个锁。  
41.                 if(!r.flag)   //等待唤醒机制，false则等待，true则执行  
42.                     try{r.wait();}catch(Exception e){}  //线程等待，进入线程池  
43.                 System.out.println(r.name+"----"+r.sex);  
44.                 r.flag = false;  //等待唤醒机制  
45.                 r.notify();  //唤醒Input线程  //等待唤醒机制  
46.             }  
47.         }  
48.     }  
49. }  
50. class ThreadCommunication{  
51.     public static void main(String[] args){  
52.         Res r = new Res();  
53.           
54.         Input in = new Input(r);  
55.         Output out = new Output(r);  
56.           
57.         Thread t1 = new Thread(in);  
58.         Thread t2 = new Thread(out);  
59.         t1.start();  
60.         t2.start();  
61.     }  
62. }  

 

 

以上代码中，把两个同步代码块中的代码，封装成两个同步方法，一个更改两个字段的值，另一个打印两个字段的值。

两个同步方法写在Res类中，这样同步锁都是Res.class字节码文件，保证了等待和唤醒是同一个锁：

[java] view plaincopy

 

1. //两个线程交替执行，在控制台交替打印两串字符串。  
2. class Res{  
3.     String name;  
4.     String sex;  
5.     boolean flag = false;   
6.       
7.     public synchronized void setRes(String name,String sex){ //同步函数  
8.         if(this.flag)    //flag为true，则线程等待进入线程池。  
9.             try{this.wait();}catch(Exception e){}   
10.         this.name = name;  //flag为false，则线程继续执行。  
11.         this .sex = sex;  
12.         this.flag = true;  
13.         this.notify();   //任意唤醒线程池中一个等待的线程  
14.     }  
15.     public synchronized void getRes(){  
16.         if(!this.flag)  //flag为false，则线程等待进入线程池。  
17.             try{this.wait();}catch(Exception e){}   
18.         System.out.println(this.name+"----"+this.sex); //flag为true则继续执行  
19.         this.flag = false;  
20.         this.notify();  //任意唤醒线程池中一个等待的线程  
21.     }  
22. }  
23. class Input implements Runnable{  
24.     private Res r;  
25.     Input(Res r){  
26.         this.r = r;  
27.     }  
28.     public void run(){  
29.         int x = 0;  
30.         while(true){  
31.             if(x == 0)  
32.                 r.setRes("LuoQi","man");  
33.             else  
34.                 r.setRes("丽丽","女");  
35.             x = (x+1)%2;      
36.         }  
37.     }  
38. }  
39. class Output implements Runnable{  
40.     private Res r;  
41.     Output(Res r){  
42.         this.r = r;  
43.     }  
44.     public void run(){  
45.         while(true){  
46.             r.getRes();  
47.         }  
48.     }  
49. }  
50. class ThreadCommunication2{  
51.     public static void main(String[] args){  
52.         Res r = new Res();  
53.           
54.         Input in = new Input(r);  
55.         Output out = new Output(r);  
56.           
57.         Thread t1 = new Thread(in);  
58.         Thread t2 = new Thread(out);  
59.         t1.start();  
60.         t2.start();  
61.     }  
62. }