多线程中wait(),notify()和notifyall()方法的含义

在“synchronized(obj){··········}”这个同步块中，obj对象叫做监控器，只有持有监控器这个对象的锁时才会执行同步块中的内容

Java中的线程的生命周期大体可分为5种状态。

1. 新建(NEW)：新创建了一个线程对象。

2. 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

3. 运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。
4. 阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种： 

(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
(三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

5. 死亡(DEAD)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

     wait(),notify()和notifyall()方法是Object类对象的方法，所以所有的对象都可以作为监控器

public class WaitNotify {
			static boolean flag = true;
			static Object lock = new Object() ;
			public static void main(String[ ] args) throws Exception {
				Thread waitThread = new Thread(new Wait() , "WaitThread") ;
				waitThread. start() ;
				TimeUnit. SECONDS. sleep(1) ;
				Thread notifyThread = new Thread(new Notify() , "NotifyThread") ;
				notifyThread. start() ;
			}
			static class Wait implements Runnable {
			public void run() {
			// 加锁， 拥有lock的Monitor
				synchronized (lock) {
				// 当条件不满足时，继续wait， 同时释放了lock的锁
					while (flag) {
						try {
							System.out.println(Thread.currentThread() + "flag is true. wait@ " + 
						    new SimpleDateFormat("HH: mm: ss").format(new Date())) ;
							lock. wait() ;
						} catch (InterruptedException e) {
						}
					}
					// 条件满足时， 完成工作
					System.out.println(Thread.currentThread() +" flag is false. running@ " + 
					new SimpleDateFormat("HH: mm: ss").format(new Date())) ;
				}
			}
			}
			static class Notify implements Runnable {
				public void run() {
					// 加锁，拥有lock的Monitor
					synchronized (lock) {
						// 获取lock的锁， 然后进行通知， 通知时不会释放lock的锁，
						// 直到当前线程释放了lock后， WaitThread才能从wait方法中返回
						System.out.println(Thread. currentThread() + " hold lock. notify @ " +
						new SimpleDateFormat("HH: mm: ss") . format(new Date() ) ) ;
						lock.notifyAll() ;
						flag = false;
						SleepUtils.second(5) ;
					}
					// 再次加锁
					synchronized (lock) {
						System.out.println(Thread.currentThread() + "hold lock again. sleep"+
					    new SimpleDateFormat("HH: mm: ss").format(new Date() ) ) ;
						SleepUtils.second(5) ;
					}
				}
			}
		}			

调用wait()、 notify()以及notifyAll()时需要注意的细节， 如下。
1） 使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
2） 调用wait()方法后， 线程状态由 RUNNING变为WAITING， 并将当前线程放置到对象的
等待队列。
3） notify()或notifyAll()方法调用后， 等待线程依旧不会从wait()返回， 需要调用notify()或
notifAll()的线程释放锁之后， 等待线程才有机会从wait()返回。
4） notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中， 而notifyAll()
方法则是将等待队列中所有的线程全部移到同步队列， 被移动的线程状态由 WAITING变为
BLOCKED。
5） 从wait()方法返回的前提是获得了调用对象的锁。

要注意的一点就是执行nitifyAll()方法时不会立刻就释放对象的锁，而是要等到线程执行完成后才会释放

但是执行wait()方法时就是会立刻释放对象的锁，然后当前线程就会卡在wait()方法处，等待唤醒

另外还有一点需要提的是这三个方法都必须被包裹在同步块中！