wait()方法：

       该方法用来使得当前线程进入等待状态，直到接到通知或者被中断打断为止。

       在调用 wait() 方法之前，线程必须要获得该对象的对象级锁；换句话说就是该方法只能在同步方法或者同步块中调用，如果没有持有合适的锁的话，线程将会抛出异常 IllegalArgumentException。调用 wait() 方法之后，当前线程则释放锁。

notify()方法：

       该方法用来唤醒等待池中处于等待状态的一个线程。

       如果有多个线程则线程规划器任意选出一个线程进行唤醒，使其去竞争获取对象锁，但线程并不会马上就释放该对象锁， wait() 所在的线程也不能马上获取该对象锁，要程序退出同步块或者同步方法之后，当前线程才会释放锁，wait() 所在的线程才可以获取该对象锁。

notifyAll()方法：

       该方法用来唤醒等待池中处于等待状态的所有线程。同 notify()方法

相同点/不同点：

   相同点：

        wait()、notify()、notifyAll()方法属于Object中的方法；对于Object中的方法，每个对象都拥有。

   不同点：

        wait()方法是释放锁的；notify()、notifyAll()方法不释放锁，必须等到所在线程把代码执行完。

实例

/**
 * TODO 等待线程01
 *
 * @author liuzebiao
 * @Date 2019-12-24 9:36
 */
public class WaitThread01 implements Runnable {

    //定义一把对象锁
    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock){
            System.out.println("开始执行:wait01()");
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("执行结束:wait01()");
        }
    }
}

/**
 * TODO 等待线程02
 *
 * @author liuzebiao
 * @Date 2019-12-24 9:36
 */
public class WaitThread02 implements Runnable {

    //定义一把对象锁
    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock){
            System.out.println("开始执行02:wait()");
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("执行结束02:wait()");
        }
    }
}

/**
 * TODO 唤醒线程 notify()/notifyAll()
 *
 * @author liuzebiao
 * @Date 2019-12-24 9:36
 */
public class NotifyThread implements Runnable {

    private Object lock;

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

    @Override
    public void run() {
        synchronized (lock){
            System.out.println("开始执行:notify()");
            lock.notify();
            //lock.notifyAll();
            System.out.println("执行结束:notify()");
        }
    }
}

/**
 * TODO 测试
 *
 * @author liuzebiao
 * @Date 2019-12-24 9:36
 */
public class Demo02 {

    public static void main(String[] args) {
        //定义一把锁
        Object lock = new Object();
        //三个线程使用同一把锁(对象锁)(lock)
        //等待线程01
        Thread waitThread01 = new Thread(new WaitThread01(lock));
        waitThread01.start();
        //等待线程02
        //Thread waitThread02 = new Thread(new WaitThread02(lock));
        //waitThread02.start();
        //唤醒线程
        Thread notifyThread = new Thread(new NotifyThread(lock));
        notifyThread.start();

    }
}

 测试结果：

开始执行:wait01()
开始执行:notify()
执行结束:notify()
执行结束:wait01()

 结果分析：

        我们可以看出：wait()方法会释放锁、 notify() 方法不会释放锁。

        等到 NotifyThread() 线程所有方法执行完成才会释放锁，此时 WaitThread() 线程才会再次获得锁。

        notifyAll() 方法同 notify() ，可以自行测试。

wait()/notify()/notifyAll()  的用法，介绍到此为止

如果本文对你有所帮助，那就给我点个赞呗 ^_^ 

End