java中wait和notify关键字的简介说明

wait()和notify()简介

 
void notify() 
唤醒在此对象监视器上等待的单个线程

void notifyAll() 
唤醒在此对象监视器上等待的所有线程

void wait( ) 
导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法

void wait(long timeout) 
导致当前的线程等待，直到其他线程调用此对象的notify() 方法或 notifyAll() 方法，或者指定的时间过完。

void wait(long timeout, int nanos) 
导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法，
或其他线程打断了当前线程，或指定的时间过完。

 
wait(),notify(),notifyAll()都不属于Thread类
而是属于Object基础类
每个对象都有wait(),notify(),notifyAll()的功能
因为每个对象都有锁，锁是每个对象的基础，当然操作锁的方法也是最基础了。

当需要调用以上的方法的时候，一定要对竞争资源进行加锁
如果不加锁的话，则会报 IllegalMonitorStateException 异常
当想要调用wait()进行线程等待时，必须要取得这个锁对象的控制权(对象监视器)

一般是放到synchronized(obj)代码中
在while循环里而不是if语句下使用wait
这样，会在线程暂停恢复后都检查wait的条件，
并在条件实际上并未改变的情况下处理唤醒通知
调用obj.wait( )释放了obj的锁
否则其他线程也无法获得obj的锁,也就无法在synchronized(obj){ obj.notify() } 代码段内唤醒A

notify()方法只会通知等待队列中的第一个相关线程(不会通知优先级比较高的线程)
notifyAll()通知所有等待该竞争资源的线程(也不会按照线程的优先级来执行)

假设有三个线程执行了obj.wait()
那么obj.notifyAll( )则能全部唤醒tread1，thread2，thread3
但是要继续执行obj.wait()的下一条语句
必须获得obj锁
因此tread1，thread2，thread3只有一个有机会获得锁继续执行
 如tread1，其余的需要等待thread1释放obj锁之后才能继续执行
当调用obj.notify/notifyAll后，调用线程依旧持有obj锁
 因此，thread1，thread2，thread3虽被唤醒
 但是仍无法获得obj锁。
 直到调用线程退出synchronized块，释放obj锁后
 thread1，thread2，thread3中的一个才有机会获得锁继续执行。

wait和notify示例分享

public class WaitNotifyTest {

    //java265.com示例分享在多线程间共享的对象上使用wait
    private String[] shareObj = { "true" };

    public static void main(String[] args) {
        WaitNotifyTest test = new WaitNotifyTest();
        ThreadWait threadWait1 = test.new ThreadWait("wait thread1");
        threadWait1.setPriority(2);
        ThreadWait threadWait2 = test.new ThreadWait("wait thread2");
        threadWait2.setPriority(3);
        ThreadWait threadWait3 = test.new ThreadWait("wait thread3");
        threadWait3.setPriority(4);

        ThreadNotify threadNotify = test.new ThreadNotify("notify thread");

        threadNotify.start();
        threadWait1.start();
        threadWait2.start();
        threadWait3.start();
    }

    class ThreadWait extends Thread {

        public ThreadWait(String name){
            super(name);
        }

        public void run() {
            synchronized (shareObj) {
                while ("true".equals(shareObj[0])) {
                    System.out.println("线程"+ this.getName() + "开始等待");
                    long startTime = System.currentTimeMillis();
                    try {
                        shareObj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println("线程" + this.getName()
                            + "等待时间为：" + (endTime - startTime));
                }
            }
            System.out.println("线程" + getName() + "等待结束");
        }
    }

    class ThreadNotify extends Thread {
        public ThreadNotify(String name){
            super(name);
        }

        public void run() {
            try {
                //让程序暂停一下
                sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (shareObj) {
                System.out.println("线程" + this.getName() + "开始准备通知");
                shareObj[0] = "false";
                shareObj.notifyAll();
                System.out.println("线程" + this.getName() + "通知结束");
            }
            System.out.println("线程" + this.getName() + "运行结束");
        }
    }
}