高工也要补基础，wait，notify，join

wait 和 notify 方法属于线程间通讯。所谓线程间通讯，是指线程 A 完成了一个动作，通知线程 B 可以继续做某动作了。

wait 和 notify 必须在同步块里才可使用，即需要配合 synchronize 关键字使用。

典型的通知场景是，生产者和消费者模型，线程 A 往队列中添加元素，线程 B 从队列中取出元素。

下面给一段示例代码：

package com.dsj361.thread;
import java.util.ArrayList;
import java.util.List;
public class WaitNotifyTest {
    private volatile List<String> list = new ArrayList<>();
    private Object lock = new Object();
    public void put() {
        synchronized (lock) {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                list.add("A");
                System.out.println("线程：" + Thread.currentThread().getName() + "添加到第" + i + "个元素");
                if (i == 5) {
                    // 发出通知，但是没有释放锁，继续把自己的代码块执行完，全部执行完后，才释放锁
                    lock.notify();
                    System.out.println("线程：" + Thread.currentThread().getName() + "发出通知");
                }
            }
        }
    }
    public void get() {
        synchronized (lock) {
            System.out.println(Thread.currentThread().getName() + "等待");
            System.out.println();
            try {
                // 执行到wait，立马交出锁，放弃cpu，进入等待状态
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (String s : list) {
                System.out.println("线程：" + Thread.currentThread().getName() + "获取元素:" + s);
            }
        }
    }
    public static void main(String[] args) {
        final WaitNotifyTest demoThread18 = new WaitNotifyTest();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demoThread18.get();
            }
        },"t1").start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                demoThread18.put();
            }
        },"t2").start();
    }
}

运行代码，输出为：

t1等待
线程：t2添加到第0个元素
线程：t2添加到第1个元素
线程：t2添加到第2个元素
线程：t2添加到第3个元素
线程：t2添加到第4个元素
线程：t2添加到第5个元素
线程：t2发出通知
线程：t2添加到第6个元素
线程：t2添加到第7个元素
线程：t2添加到第8个元素
线程：t2添加到第9个元素
线程：t1获取元素:A
线程：t1获取元素:A
线程：t1获取元素:A
线程：t1获取元素:A
线程：t1获取元素:A
线程：t1获取元素:A
线程：t1获取元素:A
线程：t1获取元素:A
线程：t1获取元素:A
线程：t1获取元素:A
Process finished with exit code 0

这段代码中，有几个要注意的点。

wait 方法和 notify 方法必须配合 synchronize 使用
线程 t2 调用 notify 方法通知后，并没有马上释放锁，可以从线程 t1 的输出中看到，t1 一直等到 t2 添加完 10 个元素后，才执行的。

等到线程 t2 执行完所有代码后，才释放锁，t1 执行

线程 t2 执行 wait 方法后，立即释放锁。可以从输出看到，t2 执行完 wait 后，t1 执行了。
线程 t1 和线程 t2 是有启动顺序的，需要先执行 wait 方法，再执行 notify 方法。

否则如果一个线程执行完 notify 方法交出锁后，另一个线程再执行 wait 方法交出锁，另一个线程就永远没有机会被唤醒了，会进入永久休眠。

另外，推荐使用 notifyAll() 方法，这个方法会唤醒所有处于等待状态的线程。而 notify 只会随机唤醒线程，可能会导致有些线程永远无法被唤醒。

为了理解这段话，可能还需要补充 synchronize 的用法。

synchronize 可以在下面三种情况下使用

同步实例方法

锁是当前实例对象，进入同步方法前，要获得当前实例对象的锁

同步静态方法

锁是当前类的 class 对象，进入同步代码前要获得当前类对象的锁

同步代码块

有时候，我们编写的方法可能非常多，会有些耗时的操作。此时我们只需要在某些代码上同步，不需要同步整个方法的代码。

那么 synchronize 是否是可重入的呢？

答案是可重入的，比如 synchronize 修饰方法1，synchronize 修饰方法2，此时方法1是可以调用方法2代码的。