线程通信方式2：通过Object类的 wait/notify 实现

对于上篇线程通信方式1：通过 volatile 关键字实现这个方法来说，我们的线程执行了很多次空循环，来等待另外一个线程来获取锁，这种操作无疑是十分消耗CPU的资源的，所以说为了解决这种情况，我们就需要一种机制可以实现线程之间的通信，可以唤醒其他的线程，而不是等待直到自己获取CPU的时间片，我们都知道，Object类提供了三个线程间通信的方法，wait()，notify()，notifyAll()。这三个方法必须都在同步代码块中执行的。

方法名	具体操作
wait()	wait()方法执行前，是必须要获得对应的锁的，当执行wait()方法后，线程就会释放掉自己所占有的锁，释放CPU，然后进入阻塞状态，直到被notify()方法唤醒。
notify()	会唤醒一个处于等待该对象锁的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。
notifyAll()	和notify()方法差不多，只不过他是唤醒所有等待该对象锁的线程，让他们进入就绪队列，但是谁执行就看谁抢占到CPU，notify()方法也是这样，只不过是唤醒随机的一个而已

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了已就绪（将要竞争锁）的线程，阻塞队列存储了被阻塞的线程。当一个阻塞线程被唤醒后，才会进入就绪队列，进而等待CPU的调度；反之，当一个线程被wait后，就会进入阻塞队列，等待被唤醒。

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author 北冥有鱼
 * @Description 需求： 两个线程操作一个共享变量，每个线程对变量执行+1操作，交替执行十次
 *                      使用Object类的 wait/notify 方法
 * @Date 2023/4/28 17:13
 */
public class Notify02_SynchronizedObject {

    //定义一个共享变量
    private static AtomicInteger atomicInteger = new AtomicInteger(0);

    public static void main(String[] args) {
        Object lock = new Object();  //创建一个锁对象
        new Thread(() -> {
            while (true) {
                synchronized (lock) {  //首先需要获取锁
//                    System.out.println("线程A获取锁");
                    try {
                        if (atomicInteger.get() % 2 == 1) {
//                            System.out.println("线程A执行等待");
                            //等待,释放锁
                            lock.wait();
//                            System.out.println("线程A执行等待后");
                        }
                        //2 干活
                        System.out.println(Thread.currentThread().getName() + "--" + atomicInteger.getAndIncrement());
                        //3 通知唤醒
                        lock.notifyAll();
//                        System.out.println("线程A执行通知===");
                    } catch (Exception e) {

                    }
                    if (atomicInteger.get() >= 10) {//到达十次，结束循环
                        break;
                    }
                }
            }
        }, "A").start();

        new Thread(() -> {
            while (true) {
                synchronized (lock) {
//                    System.out.println("线程B获取锁");
                    try {
                        if (atomicInteger.get() % 2 == 0) {
//                            System.out.println("线程B执行等待");
                            //等待,释放锁
                            lock.wait();
//                            System.out.println("线程B执行等待后");
                        }
                        //2 干活
                        System.out.println(Thread.currentThread().getName() + "----" + atomicInteger.getAndIncrement());
                        //3 通知唤醒
                        lock.notifyAll();
//                        System.out.println("线程B执行通知====");
                    } catch (Exception e) {

                    }
                    if (atomicInteger.get() >= 10) {//到达十次，结束循环
                        break;
                    }
                }
            }
        }, "B").start();
    }
}

参考：https://blog.csdn.net/weixin_43786099/article/details/119945831