写在前面：
视频是什么东西，有看文档精彩吗？
视频是什么东西，有看文档速度快吗？
视频是什么东西，有看文档效率高吗？
诸小亮：下面我们聊聊——线程通信技术
张小飞：多个线程之间还可以通信吗？
诸小亮：是的，通过调用锁对象的wait()、notify()方法，可以实现线程通信
张小飞：那具体如何使用呢？
1. 体验
诸小亮：首先，Object 类中有 wait()、notify() 这两个方法
- wait()：让当前线程进入等待状态
- 使用方式：锁对象.wait()，必须放到 同步代码块 或 同步方法 中
- notify()：唤醒对应的正在 wait 的线程
- 使用方式：锁对象.notify()，必须放到 同步代码块 或 同步方法 中
- 调用 wait() 和 notify() 的锁对象必须是同一个
张小飞：大概明白，不过还需要您给出具体的代码
诸小亮：代码也给你准备好了，注意代码中的注释
class Hero implements Runnable{
//1. 搞一个锁对象
public static Object lock = new Object();
@Override
public void run(){
synchronized (lock){
System.out.println(Thread.currentThread().getName() + "。。。。。。。获取锁，然后进入等待状态");
try {
//2. 让当前线程等待，使用方式：锁对象.wait()，而且必须放到同步代码块或者同步方法中
lock.wait();
} catch (InterruptedException e) { }
System.out.println(Thread.currentThread().getName() + "。。。。。。。结束");
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws Exception {
//3. 创建一个 yase 线程
Thread yase = new Thread(new Hero(),"yase");
yase.start();
//4. 主线程休眠2秒
Thread.sleep(2000);
//5. 使用notify唤醒yase线程，让他继续执行
synchronized (Hero.lock){
System.out.println("主线程唤醒yase。。。。。。。");
//使用方式：锁对象.notify()，唤醒对应的正在等待状态的线程，必须放到同步代码块或者同步方法中
Hero.lock.notify();
}
}
} 结果：
诸小亮：你能解释一下这个代码的执行过程吗？
张小飞：当然可以
yase线程先执行，在执行 lock.wait() 代码后，进入等待状态
main 线程在休眠 2 秒后，执行 Hero.lock.notify(); 去唤醒 yase 线程
yase线程被唤醒后，接着执行，最后输出：yase。。。。。。。结束 诸小亮：不错啊
2. 注意点
诸小亮：使用 wait、notify时，需要特别注意一些地方
张小飞：都需要注意什么？
1. wait、notify必须放到同步代码块或同步方法中
诸小亮：第一，wait、notify必须放到同步代码块或同步方法中
张小飞：哦~，这个刚才说过，不过如果不放到它里面呢？
诸小亮：那调用 wait 方法时就会报错，比如：
结果：
张小飞：明白了，不过这个异常是？
诸小亮：非法的监控状态异常，线程从启动到死亡有不同的状态，之后会解释
张小飞：好的
2. 锁对象是this
张小飞：如果锁对象是 this 呢？
诸小亮：如果锁对象是this，那么：this.wait()，记住必须是：锁对象.wait()，否则：
上图，锁对象是this，但是却调用 lock.wait();，结果：
张小飞：记住了
3. 锁对象.notify()
张小飞：既然必须是 锁对象.wait()，那么也肯定必须是：锁对象.notify()
诸小亮：没错，否则也会报错，比如：
上图，锁对象是Hero.class，但是却调用Hero.lock.nodify()；结果：
4. 调用 wait() 和 notify() 的锁对象必须是同一个
诸小亮：还有，调用 wait() 和 notify() 的锁对象必须是同一个，否则：
结果：
张小飞：看输出，程序一直没有结束吧
诸小亮：是的，其原因
- Hero.class.notify();只能唤醒锁对象是Hero.class 且 执行了 Hero.class.wait() 的线程
- yase线程的锁对象是lock，执行了lock.wait()，一直在等待被人唤醒，所以程序一直不结束
5. 执行 notify 后，正在 wait 的线程并不是立即运行
张小飞：我发现一个现象
诸小亮：什么现象？
张小飞：执行 notify 后，正在 wait 的线程并不是立即运行，需要等待执行 notify 的线程释放锁
结果：
诸小亮：嗯，你说的很对，这也是一个需要关注的地方
6. wait()等待时，会释放锁对象
张小飞：还有一个问题，执行 wait() 方法后，是不是就释放锁对象了？
诸小亮：不错，只有释放了锁对象，main线程才能进入 synchronized 代码中
上图可以看出，yase先执行，如果wait()不释放锁，那么就无法执行Hero.lock.notify()这句代码
7. 多个线程都在wait()，notify只会随机的唤醒一个
张小飞：如果有多个线程都调用了 wait() 方法呢？
诸小亮：问得好，不过，你何不自己试一试呢？
张小飞：嗯嗯，好的
public static void main(String[] args) throws Exception {
//创建 2 个线程
Thread yase = new Thread(new Hero(),"yase");
yase.start();
Thread laoyase = new Thread(new Hero(),"laoyase");
laoyase.start();
Thread.sleep(2000);
//使用方式：锁对象.notify()，唤醒对应的正在等待状态的线程，必须放到同步代码块或者同步方法中
synchronized (Hero.lock){
System.out.println("主线程唤醒。。。。。。。");
Hero.lock.notify();//有多个线程都在wait()，notify只会随机的唤醒一个
}
} 结果：
张小飞：结果出来了，yase线程结束了，但是 laoyase 这个线程还在阻塞
诸小亮：其实你多执行几次，会发现——多个线程都在wait()，notify只会随机的唤醒一个
张小飞：好的，我再试试
8. notifyAll()
张小飞：有没有可以把所有都在 wait 中的线程，都唤醒呢？
诸小亮：如果想全部唤醒，可以使用notifyAll()，或者执行多次notify()，比如：
结果：
另外，执行多次notify()方法也可以，全部唤醒，比如：
结果：略
9. 特殊情况下的notify
诸小亮：特殊情况下的 notify 方法会唤醒所有
张小飞：这是什么意思？
诸小亮：来，看代码，注意代码中的注释
class Hero extends Thread{
public void run(){
//1. 注意这里的锁对象是this
synchronized (this){
//2. 执行 notify 唤醒所有
this.notify();
System.out.println("lock线程运行----"+this.getName());
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws Exception {
//3. 创建一个Thread对象，作为锁对象
Hero yase = new Hero();
yase.setName("yase");
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程daji开始运行。。。。。。");
//4. 注意，这里的锁对象是一个线程对象
synchronized (yase){
try {
yase.wait();
System.out.println("线程daji结束----"+yase.getName());//输出lock线程的名称
} catch (InterruptedException e) {
}
}
}
}, "daji").start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程lvbu开始运行。。。。。。");
//4. 注意，这里的锁对象是一个线程对象
synchronized (yase){
try {
yase.wait();
System.out.println("线程vbul结束----"+yase.getName());
} catch (InterruptedException e) {
}
}
}
}, "lvbu").start();
Thread.sleep(2000);
//5. 启动 yase 线程
yase.start();
}
} 结果：
张小飞：这个代码能否具体解释一下？
诸小亮：当然可以
首先创建一个名为 yase 的线程对象
然后创建了 daji、lvbu 两个线程，这两个线程都把 yase 对象作为锁对象
这两个线程分别启动后都执行 wait 方法，进入等待模式
最后yase线程启动，执行run方法时，调用 this.notify();
结果：daji、lvbu 都被唤醒 张小飞：这是什么原理？
诸小亮：额。。。。，很抱歉我也没仔细研究过，暂时记住这个现象吧
张小飞：好的
3. 生产消费模式
诸小亮：接着我们说一个——生产消费模式
张小飞：这是做什么的？
诸小亮：生产者生产数据，消费者消费数据，先看一张图
张小飞：您是先说，面包师生产面包，放到面包柜，然后销售员再取走面包吗？
诸小亮：是的，这就是我们生活中的——生产消费模式
诸小亮：工作中，wait()、notify() 经常用于生产消费模式
张小飞：具体怎么使用呢？
诸小亮：给你一个需求，生产者生产商品，如果货架上已经有商品就不再生产，
消费者消费商品，如果货架上没有就通知生产者
示例：
class Goods{
String name = "哈根达斯";
//0：表示货架上没有商品，需要生产
//1：表示货架上已有商品，需要消费
int count = 0;
}
//消费者
class Consumer implements Runnable{
private Goods goods;
Consumer(Goods goods){
this.goods = goods;
}
@Override
public void run(){
while (true){
synchronized (goods){
if(goods.count == 1){
System.out.println(Thread.currentThread().getName()+"。。。。。。消费商品---"+goods.count);
goods.count = 0;//消费商品
goods.notify();//唤醒消费者
//让自己自己等待
try {goods.wait();} catch (InterruptedException e) {}
}
}
}
}
}
//生产者
class Producer implements Runnable{
private Goods goods;
Producer(Goods goods){
this.goods = goods;
}
@Override
public void run(){
while (true){
synchronized (goods){
if(goods.count == 0){
System.out.println(Thread.currentThread().getName()+"。。。。。。生产商品---------"+goods.count);
goods.count = 1;//生产商品，设置count=1
goods.notify();//唤醒消费者
//自己等待
try {goods.wait();} catch (InterruptedException e) {}
}
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws Exception {
Goods goods = new Goods();
new Thread(new Producer(goods), "伊利").start();
new Thread(new Consumer(goods), "亚瑟").start();
}
} 结果中，两个线程互相唤醒，交替执行
诸小亮：怎么样，可以看懂吗？
张小飞：可以可以，原来这就是生产消费模式
4. wait 和 sleep
张小飞：我突然先到，sleep 也是可以暂停线程的
诸小亮：不错， wait 和 sleep 有相同点，也有区别，这也是面试常见的一个问题
张小飞：那么它们都有什么不同的地方呢？
诸小亮：都给你总结好了，自己看看吧
相同点：都可以暂时停止一个线程
不同点：
sleep必须指定睡眠时间，wait可以指定也可以不指定
sleep是 Thread 的静态方法，wait是 Object 类的成员方法
sleep 不释放锁，wait 释放锁
sleep 等待一定时间后自定运行，wait需要 notify 或 notifyAll 唤醒
wait 必须配合synchronized使用，sleep不必
sleep 会让线程进入 TIMED_WAITING 状态，wait让线程进入 WAITING 状态（之后会详细解释线程状态）