Java 同步方式 (2) —— wait和notify/notifyall

Java 中除了关键字 synchronized 能够实现线程同步外，还可以使用 wait 和 notify/notify 实现同步。

wait 方法是使拥有当前对象（object）的线程（thread）放弃锁(release lock)，进入睡眠状态

notify 通知该对象（object）因上面调用wait而等待的某一进程重新唤醒启动

notifyAll 通知在对象（object）上因调用wait而等待的所有进程启动，这些进程根据优先级顺序执行

一个线程在其生命周期内总是处于某种状态：

1. 创建： 当一个线程对象被声明并创建后，它处于“创建”状态；
2. 就绪：线程对象调用 start() 方法后，将进入“就绪”状态，处于“就绪”状态的线程不是立即执行，而是进入就绪队列，等待CPU；
3. 运行：当就绪队列中具有最高优先级的就绪线程被调度并获得CPU时，便进入“运行”状态，执行 run() 方法，run 方法中定义了线程的操作和功能；
4. 非运行：处于“运行”状态的线程可能因为某些原因 (例如人为挂起)进入“非运行”状态，让出CPU并临时中止自己的执行；
5. 停止：线程完成了它的全部工作或调用 stop() 方法强制中止线程，线程就进入“停止”状态。

wait 与 sleep 区别

wait

sleep

归属类

属于Object类（java.lang.Object）

属于Thread类（java.lang.Thread），静态方法

释放锁

释放了锁，其它线程同步块或方法

没有释放锁，不出让系统资源（如cpu）

中断唤醒

wait一般不会加时间限制，而是判断是否满足符合条件；

如果符合条件，则notify/notifyall唤醒

sleep(milliseconds)后自动唤醒，

如果时间不到可用interrupt()强制中断

适用范围

同步方法或同步块使用（synchronized）

任何地方都可使用（main、thread线程）

捕获异常

必须捕获异常（try/catch）

不需要捕获异常

wait - sleep 示例（区别）

[java] view plaincopyprint?

1. package com.homer.thread; 
2.  
3. public class waitsleep { 
4.     public staticvoid main(String[] args) { 
5.         ThreadDemo th = new ThreadDemo(); 
6.          
7.         th.start(); 
8.         System.out.println("thread is starting..."); 
9.          
10.         synchronized (th) { 
11.             try { 
12.                 System.out.println("Waiting for th to complete..."); 
13. //              th.wait(1000);      // 等待1秒后，立刻执行 
14.                 th.wait();          // 线程等待，notify唤醒后执行 
15.             } catch (Exception e) { 
16.                 e.printStackTrace(); 
17.             } 
18.             System.out.println("Total is : " + th.total);  // 线程唤醒后，执行 
19.         } 
20.     } 
21. } 
22.  
23. class ThreadDemo extends Thread { 
24.     int total; 
25.      
26.     @Override 
27.     public void run(){ 
28.         try { 
29.             Thread.sleep(2000);    // 睡眠2秒 
30.             synchronized(this){ 
31.                 System.out.println("Thread is running..."); 
32.                 for(int i=0; i<10; i++) { 
33.                     total += i; 
34.                     System.out.println("i = " + i +"; total = " + total); 
35.                      
36.                     if(i==5) { 
37.                         System.out.println("i = 5 sleep(3000)"); 
38.                         Thread.sleep(3000);    // i = 5时，睡眠3秒 
39.                     } 
40.                 } 
41.                 this.notify(); 
42.             } 
43.         } catch (Exception e) { 
44.             e.printStackTrace(); 
45.         } 
46.     } 
47. } 

package com.homer.thread;public class waitsleep {public static void main(String[] args) {ThreadDemo th = new ThreadDemo();th.start();System.out.println("thread is starting...");synchronized (th) {try {System.out.println("Waiting for th to complete...");//th.wait(1000);// 等待1秒后，立刻执行th.wait();// 线程等待，notify唤醒后执行} catch (Exception e) {e.printStackTrace();}System.out.println("Total is : " + th.total);// 线程唤醒后，执行}}}class ThreadDemo extends Thread {int total;@Overridepublic void run(){try {Thread.sleep(2000);// 睡眠2秒synchronized(this){System.out.println("Thread is running...");for(int i=0; i<10; i++) {total += i;System.out.println("i = " + i + "; total = " + total);if(i==5) {System.out.println("i = 5 sleep(3000)");Thread.sleep(3000);// i = 5时，睡眠3秒}}this.notify();}} catch (Exception e) {e.printStackTrace();}}}

运行结果：

thread is starting...
Waiting for th to complete...
Thread is running...
i = 0; total = 0
i = 1; total = 1
i = 2; total = 3
i = 3; total = 6
i = 4; total = 10
i = 5; total = 15
i = 5 sleep(3000)
i = 6; total = 21
i = 7; total = 28
i = 8; total = 36
i = 9; total = 45
Total is : 45

================================

wait - notify 示例（生产者 - 消费者）

[java] view plaincopyprint?

1. package com.homer.thread; 
2.  
3. public class waitnotify { 
4.     public staticvoid main(String[] args) { 
5.         Q q = new Q(); 
6.         new Producer(q); 
7.         new Consumer(q); 
8.     } 
9. } 
10.  
11. class Producer implements Runnable { 
12.     Q q = null; 
13.      
14.     public Producer(Q q) { 
15.         this.q = q; 
16.         (new Thread(this,"Producer")).start(); 
17.     } 
18.      
19.     @Override 
20.     public void run() { 
21.         int i = 0; 
22.         while(i<5) { 
23.             q.put(i++); 
24.         } 
25.     } 
26. } 
27.  
28. class Consumer implements Runnable { 
29.     Q q = null; 
30.      
31.     public Consumer(Q q) { 
32.         this.q = q; 
33.         (new Thread(this,"Consumer")).start(); 
34.     } 
35.  
36.     @Override 
37.     public void run() { 
38.         while(q.get()<5){ 
39.         } 
40.     } 
41. } 
42.  
43. class Q { 
44.     int n; 
45.     boolean valueSet = false; 
46.      
47.     public synchronizedint get() { 
48.         if(!valueSet) {     // if valueSet == false,wait else try to got value 
49.             try { 
50.                 wait(); 
51.             } catch (InterruptedException e) { 
52.                 e.printStackTrace(); 
53.             } 
54.         }  
55.          
56.         System.out.println("Get n : " + n); 
57.         valueSet = false; 
58.         notify(); 
59.          
60.         return n; 
61.     } 
62.      
63.     public synchronizedvoid put(int n) { 
64.         if(valueSet) {      // if valueSet == true,already have value so wait fetch,else put 
65.             try { 
66.                 wait(); 
67.             } catch (InterruptedException e) { 
68.                 e.printStackTrace(); 
69.             } 
70.         } 
71.          
72.         this.n = n; 
73.         System.out.println("Put n : " + n); 
74.         valueSet = true; 
75.         notify(); 
76.     } 
77. } 

package com.homer.thread;public class waitnotify {public static void main(String[] args) {Q q = new Q();new Producer(q);new Consumer(q);}}class Producer implements Runnable {Q q = null;public Producer(Q q) {this.q = q;(new Thread(this, "Producer")).start();}@Overridepublic void run() {int i = 0;while(i<5) {q.put(i++);}}}class Consumer implements Runnable {Q q = null;public Consumer(Q q) {this.q = q;(new Thread(this, "Consumer")).start();}@Overridepublic void run() {while(q.get()<5){}}}class Q {int n;boolean valueSet = false;public synchronized int get() {if(!valueSet) {// if valueSet == false,wait else try to got valuetry {wait();} catch (InterruptedException e) {e.printStackTrace();}} System.out.println("Get n : " + n);valueSet = false;notify();return n;}public synchronized void put(int n) {if(valueSet) {// if valueSet == true,already have value so wait fetch,else put try {wait();} catch (InterruptedException e) {e.printStackTrace();}}this.n = n;System.out.println("Put n : " + n);valueSet = true;notify();}}

运行结果：

Put n : 0
Get n : 0
Put n : 1
Get n : 1
Put n : 2
Get n : 2
Put n : 3
Get n : 3
Put n : 4
Get n : 4

首先两个线程启动，他们的执行占用CPU多少随机，但是这里因为加了一个锁的Boolean型变量，而控制了put与set.

首先：创建了一个对象Q，创建了一个Producer，一个Consumer，这两个对象在构造方法中启动了线程.
第一步：
    对于Producer来说，会首先去调用put方法，因为valueSet是默认值是false，所以在Q的put方法不执行wait 而是执行 this.n = n 赋值操作，执行完毕后设置为valueSet = true
    对于Consumer来说，会首先去调用get方法，因为valueSet是默认值是false，所以该线程会执行wait（等待valueSet 赋值状态为true）
第二步：
   对于Producer来说，因为valueSet已经变成true，所以会wat.
   对于Consumer来说，因为valueSet已经变成true，所以会执行下面的code(get value)，然后设置valueSet为false.
第三步：
   Producer执行put方法，因为valueSet为false
   Consumer等待（重复第一步）
依次类推，方法执行...

这里关键是加了一个共享的变量 valueSet 来判是该取值get，还是put值。当然有了wait跟notify才使它成为了可以实现的。
但是不管怎样，wait是使目前控制该对象（Q的对象q）的线程wait（等待），notify是使前面在该对象上面wait的方法继续执行.