概念

1. synchronized：同步锁，可修饰方法、代码块；
2. wait：使当前线程进入等待状态，直到锁定对象被唤醒；可指定最大等待时间，自动唤醒；
3. notify：随机唤醒当前对象上等待的单个线程；
4. notifyAll：唤醒当前对象上等待的所有线程；

sleep

1. sleep 不会释放锁，而 wait 会；
2. wait 可不指定时间；
3. sleep 存在 Thread 中，而 wait 存在 Object 中；

wait、notify使用场景

synchronized 是同步锁，目的是在同步代码块中获取锁，其他线程没持有锁则不能访问，从而保证共享数据线程安全。wait是释放当前对象锁，并且使得当前线程等待，notify（notifyAll）是唤醒对象上等待获取锁的线程，所以wait、notify、notifyAll都必须写在synchronized同步代码区中，否则出现IllegalMonitorStateException异常。

假设一个消费线程，消费操作（减库存）必须是同步的，然后对库存加锁，那么这里就有判断，如果库存不大于0，释放锁，使当前线程等待，知道生产线程（加库存）唤醒，可能很多人这样写：

synchronized(库存){
  if(库存为空){
    库存.wait();
  }
  // 执行消费，减库存
}

咋的一看这样没问题，消费之前判断库存大小，空则释放锁，等待被唤醒，但问题来了，不只是生产线程能够唤醒，可能在其他地方库存被唤醒，但是实际库存并没有变化，就会导致库存大小为负数问题。所以，这里要改为：

synchronized(库存){
  while(库存为空){
    库存.wait();
  }
  // 执行消费，减库存
}

所以 wait 方法一定是在循环中调用，而不是 if 语句。

编码实践

使用wait、notify实现两个线程交替相加；

package com.cjt;

import java.util.concurrent.atomic.LongAdder;

public class App {

    public static void main(String[] args) {
        LongAdder count = new LongAdder();
        new Thread(() -> {
            while (true) {
                synchronized (count) {
                    while (count.intValue() % 2 == 0) {
                        try {
                            count.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    count.increment();
                    System.out.println(Thread.currentThread().getName() + ":" + count.intValue());
                    count.notify();
                }
            }
        }).start();

        new Thread(() -> {
            while (true) {
                synchronized (count) {
                    while (count.intValue() % 2 == 1) {
                        try {
                            count.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    count.increment();
                    System.out.println(Thread.currentThread().getName() + ":" + count.intValue());
                    count.notify();
                }
            }
        }).start();
    }
}

运行日志：

Thread-1:1
Thread-0:2
Thread-1:3
Thread-0:4
...

使用LongAdder作为共享变量，一个线程判断为奇数加1并notify该共享变量上等待的线程，为偶数则wait等待，另一个线程刚好相反；