wait/notify,notifyAll

• wait之后，持有对象锁的线程 A会释放当前锁，释放 cpu 资源进入waiting状态.

• notify :表示持有对象锁的线程A 会释放当前锁，通知JVM唤醒某个竞争该对象锁线程的线程X，线程A的Synchronized代码块执行完并释放了锁之后，线程X会有机会获得对象锁的权限（注意这里线程X也不是一定会争抢到锁，因为线程A有可能会再次获取到锁），其他竞争线程继续等待。（即使线程X执行完毕，释放了对象锁，其他竞争线程仍然等待，直至有新的notify或者notifyAll）

• notifyAll： notify和notifyAll的区别在于，notifyAll会唤醒所有竞争同一个对象锁的线程，当已经获得锁的线程A释放锁之后，所有被唤醒的线程都有可能获得对象锁的权限。
  

• 调用wait首先会获取监视器锁，获得成功后，会让线程进入等待队列，并且释放锁。

• 然后其他线程调用notify或者活notifyAll，会从等待队列中唤醒任意个线程

• 执行完notify方法后，并不会立马唤醒线程，原因是当前线程仍然持有锁，必须等到当前线程执行完毕，按照monitorexit指令之后，也就是释放之后，处于等待队列的线程就可以开始竞争锁了（不是一定会竞争到锁，原来执行完毕notify的线程也可能会再次获取到锁）。

• 当把线程对象作为对象锁的时候，不需要调用notify方法，也可以唤醒线程。

public class WaitTest2 {
    public static void main(String[] args) throws InterruptedException {


        final Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                // 将线程对象t1作为对象锁
                synchronized (this) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "  开始执行");
                        sleep(3000);
                        System.out.println(Thread.currentThread().getName() + "  执行完毕，开始notify");
                        //  注意这里并没有调用notify方法，是否会唤醒t2线程呢？
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                // 将线程对象t1作为对象锁
                synchronized (t1) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "  开始wait");
                        System.out.println(Thread.currentThread().getName() + "  开始wait 2s");
                        t1.wait();
                        System.out.println(Thread.currentThread().getName() + "  已经被唤醒执行");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t2.start();

        t1.start();
    }
}

注意上面一块代码，将t1作为对象锁，这里可以多运行几次，让t2先执行，t1后面执行，那么再t1执行完毕之后，是否会唤醒t2线程呢？ 这里并没有notify，看运行结果

可以发现，即使t1没有执行t1.notify，t2依然 被唤醒，

如果这里对象锁不是线程Thread类型的，而且其他对象类型，比如String等，这种就必须要手动调用notify释放

锁池和等待池

锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池中
所以我们可以很容易看到这两者的区别了：

如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争