java并发编程之美-第1章 并发编程线程基础-线程通知与等待（wait/notify,notifyAll）

前言

Object类是所有类的父类，鉴于继承机制，Java把所有类都需要的方法放到了 Obiect类里面，其中就包含通知（notify，notifyAll）与等待(wait)系列函数。

1. wait()函数

当一个线程调用一个共享变量的wait()方法时，该调用线程会被阻塞挂起，直到发生下面事情才返回:
(1)其他线程调用了该共享对象的 notify()或者 notifyA11() 方法
(2)其他线程调用了该线程的interrupt()方法，该线程抛出InterruptedException 异常返回
另外需要注意的是，如果调用wait()方法的线程没有事先获取该对象的监视器锁，则调用 wait()方法时调用线程会抛出 IllegalMonitorStateException异常。
那么一个线程如何才能获取一个共享变量的监视器锁呢?
(1)执行 synchronized 同步代码块时，使用该共享变量作为参数。

synchronized(共享变量){
//doSomething
}

(2)调用该共享变量的方法，并且该方法使用了synchronized 修饰。

synchronized void add(int a,int b){
//doSomething
}

下面是简单的wait和notify的使用：

public class SimpleWaitNotify extends Thread{
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        new Thread(()->{
            //细节1：wait方法与notify方法必须要由同一个锁对象调用。
            //因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
            synchronized (lock) {
                try{
                    System.out.println("wait 之前->");
                    //细节2：wait方法与notify方法是属于Object类的方法的。
                    //因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
                    lock.wait();
                    System.out.println("wait 之后->");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        Thread.sleep(500);
        //细节3：wait方法与notify方法必须要在`同步代码块`或者是`同步函数`中使用。
        //因为：必须要`通过锁对象`调用这2个方法。否则会报java.lang.IllegalMonitorStateException异常.
        synchronized (lock){
            System.out.println("notify 操作后->");
            lock.notify();
        }
    }
}

下面是简单的wait和interrupt的使用：

public class WaitNotifyInterupt {
    static Object obj= new Object();
    public static void main(String[] args) throws InterruptedException {
        //创建线程
        Thread threadA = new Thread(new Runnable() {
            public void run () {
                try {
                    System.out.println("－－－begin--");
                    //阻塞当前线斗呈
                    synchronized (obj) {
                        obj.wait();
                    }
                    System.out.println("---end---");
                } catch (InterruptedException e ) {
                    e.printStackTrace();
                }
            }
        });
        threadA.start() ;
        Thread.sleep(1000) ;
        System.out.println ("－一－begin interrupt threadA一－－");
        threadA.interrupt ();
        System.out.println("---end interrupt threadA---");
    }
}