等待通知机制（wait/notify）

wait方法

• wait的作用是使当前执行代码的线程进行等待，该方法用来将当前线程置入"预执行队列"中，并且在wait所在代码处停止执行，直到接到通知或被中断为止。
• 在调用wait之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait方法。如果调用wait时，没有持有适当的锁，则抛出IllegalMonitorStateException
• 在执行wait方法后，当前线程释放锁。
• 在从wait返回前，线程与其他线程竞争重新获得锁。

notify方法

• 方法notify也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁。如果调用notify时没有持有适当的锁，也会抛出IllegalMonitorStateException。
• 该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。
• 在执行notify方法后，当前线程不会马上释放对象锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify方法的线程将程序执行完，也就是退出synchronized代码后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。
• 当第一个获得了该对象锁的wait线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，还会继续阻塞在wait状态，直到这个对象发出一个notify或notifyAll

    public final native void notify();

    public final native void notifyAll();

    public final native void wait(long var1) throws InterruptedException;

执行notify之后，唤醒一个调用了wait之后阻塞的线程，使其进入就绪状态，被重新唤醒的线程会试图重新获得临界区的控制权，也就是锁，并继续执行临界区内wait之后的代码

public class CreateThread4 {
    public static void main(String[] args) throws InterruptedException{
        Object lock=new Object();

        Thread thread = new MyThread(lock);
        thread.start();
        Thread.sleep(100);
        Thread thread1 = new MyThread1(lock);
        thread1.start();
    }
}
class MyThread extends Thread{
    private Object lock;

    public MyThread(Object lock) {
        this.lock = lock;
    }
    @Override
    public void run() {
        synchronized (lock) {
            if (MyList.size() != 5) {
                System.out.println("wait begin");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("wait end");
            }
        }
    }
}
class MyThread1 extends Thread{
    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock) {
            for (int i = 1; i <= 10; i++) {
                MyList.add();
                if (MyList.size() ==5) {
                    lock.notify();
                    System.out.println("已发出通知！");
                }
                System.out.println("添加了"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}
class MyList {
    private static List list=new ArrayList();

    public static void add() {
        list.add("anyString");
    }
    public static int size() {
        return list.size();
    }
}

首先进入MyThread线程，此时 list.size()=0不等于5,输出wait begin，然后调用wait，线程进入等待队列，MyThread1 开始执行，在for循环中一直添加元素，直到=5，执行notify，但是并没有退出该循环，还在继续执行，直到退出synchronized，然后执行MyThread中wait之后的代码

总结：
1.执行notify之后，当前线程不会马上释放对象锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify方法的线程将程序执行完，也就是退出synchronized代码后，当前线程才会释放锁
2.执行notify之后，唤醒一个调用了wait之后阻塞的线程，使其进入就绪状态，被重新唤醒的线程会试图重新获得临界区的控制权，也就是锁，并继续执行临界区内wait之后的代码。