Object中wait和notify

#### Object

类 Object 是类层次结构的根类。所以这个类中的一些还是要重点了解一下。

wait

api解释: 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。将当前线程置入”预执行队列”中，并且wait()所在的代码处停止执行，直到接到通知或被中断异常。

在调用wait()之前，线程必须获得该对象的锁，因此只能在同步方法/同步代码块中调用wait()方法，执行该方法后，所操作的线程会释放锁，它的作用使当前执行的线程停止下来。

notify

api解释:唤醒在此对象监视器上等待的单个线程。由这句话，我们可以知道，执行该方法后，线程规划器随机挑选出一个wait的线程，对其发出通知notify()，（如果是唤醒所有，这可以用notifyall方法）它会到线程置入”预执行队列”中，寻找和它有一致的对象监视器的等待线程，让他进入可执行状态。他的作用是来原来停止的线程继续执行。

wait、notify小例子

    Object lock = new Object();//确保同一个对象监视器。
        Test124 t = new Test124();
        Thread m = new Thread(t.new MyThread1(lock));
        Thread m1 = new Thread(t.new MyThread2(lock));
        m.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        m1.start();
    }
    class MyThread1 implements Runnable{
       Object lock = null;

       public MyThread1(Object lock) {
        super();
        this.lock = lock;
    }


        @Override
        public void run() {
            // TODO Auto-generated method stub
            synchronized (lock) {//同步代码块
                System.out.println("我是被通知的线程开始时间"+System.currentTimeMillis());
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("我是被通知的线程结束时间"+System.currentTimeMillis());
            }
        }

    }

    class MyThread2 implements Runnable{
           Object lock = null;


            public MyThread2(Object lock) {
            super();
            this.lock = lock;
        }
            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (lock) {
                    System.out.println("我是被唤醒的线程开始时间"+System.currentTimeMillis());
                    lock.notify();
                    System.out.println("我是被唤醒的线程结束时间"+System.currentTimeMillis());

                }
            }

效果图:

在执行出来的效果，你会发现，当线程通知了之后，等待的线程并不是，立即执行，它需要等待通知的线程释放锁之后，这点需要注意。

在上述的代码，我们强调了wait和notify必须是同一个对象监视器，下面我们稍加验证：

Object lock = new Object();
        Object lock1 = new Object();

在原来代码不变的情况下，在添加一个对象，作为对象监视器，你就会发现问题的所在。

为什么会出现这样的情况，你看，在执行到notify的方法后，会去寻找基于lock1对象监视器下的等待线程，而此时等待的线程，是基于lock对象监视器，所以找不到，就一直耗着。看了这个你下次就会注意我强调的。

上面的还可以进行测试，你发现上面通知线程发出通知了，而等待的线程由于对象监视器不同，就一直停在那边，不好。所以，我们就可以使用wait（long time）这个方法，设置等待的超时时间，如果超了等待时间，那就不要等待，等待线程，将在原先停止的地方，进行继续执行（前提，该线程要分配到cpu）

最后，如果wait()方法和notify()/notifyAll()方法不在同步方法/同步代码块中被调用，那么虚拟机会抛出java.lang.IllegalMonitorStateException，注意一下。

参考：https://www.cnblogs.com/xrq730/p/4853932.html