漫画：Object类很大，你忍一下（完结篇）

刺骨的言语ヽ痛彻心扉 2022-09-02 11:41 148阅读 0赞

在上一篇当中，我们提及了Java语言Object类的九大方法，并重点讲解了其中的getClass()，finalize()，toString()，equals()，hashcode()。

没看过的小伙伴，可以点击阅读上一篇：[漫画：Object类很大，你忍一下][Object]

这一次，我们来重点讲解 wait()，notify()，notifyAll() 这三大方法。

![57d371c95912411b360bda33b79980a7.png][]

![7f267204a9bef8354ec7435f0f658388.png][]

![4f7a9c9a2599acd5ecc5eb8fce801262.png][]

![c97eef3f843b851a6e5a096474ba6f89.png][]

![1cfd5e10567546f2d9a1b441e8157a6b.png][]

// 执行这个方法后，持有此对象监视器的线程会进入等待队列，同时释放锁
    // 如果不在synchronized修饰的方法或代码块里调用，则会抛出IllegalMonitorStateException 异常
    // 如果当前线程在等待时被中断，则抛出InterruptedException异常
    public final void wait() throws InterruptedException {
        wait(0);
    }
    
    // timeout是线程等待时间，时间结束则自动唤醒，单位ms
    // Java默认的实现方式，native实现
    public final native void wait(long timeout) throws InterruptedException;
    
    // nanos是更精确的线程等待时间，单位ns（1 ms = 1,000,000 ns）
    // Java默认的实现方式
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                    "nanosecond timeout value out of range");
        }
        if (nanos > 0) {
            timeout++;
        }
        wait(timeout);
    }

![3bbddb0f08d40dad041d1c867a459d13.png][]

![2dba0f9e8488da877cdef32ba5d0a82d.png][]

![33e9c1a55079a42bac50045b04c68e51.png][]

含参数的wait()方法调用以后，线程可以在等待时间结束后被唤醒；无参的wait()方法调用后，则必须等待持有该对象监视器的线程主动调用notify()或notifyAll()方法后才能被唤醒。

两者之间的区别，在于notify()方法唤醒在此对象监视器上等待的**单个线程**，而notifyAll()方法则唤醒在此对象监视器上等待的**所有线程**。

与wait方法一样，执行notify方法的线程也必须提前获取锁。需要注意的是，被notify方法唤醒的线程并不会立即执行，因为要等调用notify方法的线程释放锁之后才会获取到锁。

![537b71495b41693cbb14e71e02d9995d.png][]

![a69c206ade5f97a7a49035ec335588ff.png][]

有的Java虚拟机（VM）会选择最先调用wait方法的线程，也有的则会随机选择一个线程。尽管notify方法的处理速度比notifyAll方法更快，但使用notifyAll方法更为稳妥。

notify与notifyAll的方法声明如下：

public final native void notify();
    public final native void notifyAll();

![67a7fd6bf14ea24aca5a934d81459470.png][]

![653f59c79c45f7f2c8e16613c742249d.png][]

![02a03bea1e5f8ca13816786db4338d6a.png][]

![d524c51564e0239ee5f8197ee3cf5feb.png][]

![6798633cad3a1207d352c182ad6cfb7a.png][]

有一家公司开始想要招聘程序员，于是面试了几名候选人：

![94a1b638d689cb76dad4f915beb5b220.png][]

但公司录用程序员的时间是不确定的，需要综合考虑，无法给出及时反馈。于是告诉他们回去等通知。

![80ef89cbe349e78bf0456b2547804c12.png][]

经过事后的比较和研究，面试官觉得大黄是招聘的最佳人选，于是让HR小姐姐通知大黄，也就是“唤醒”了大黄：

![ef72d4512c147862fe806a286a410767.png][]

![18c3fbd2e7f6510cd52a8d30b9742007.png][]

![bfb5eb7562678698a55b2d132401250e.png][]

（1）wait()、notify()和notifyAll()必须在synchronized修饰的方法或代码块中使用。

（2）在while循环里而不是if语句下使用wait()，确保在线程睡眠前后都检查wait()触发的条件（防止虚假唤醒）。

（3）wait()方法必须在多线程共享的对象上调用。

![0a815a0ac82795a1d8b767177281919f.png][]

![511b8a23d17e9d0a51558fffb4681ee6.png][]

生产者/消费者模型能解决绝大多数并发问题，通过平衡生产线程和消费线程的工作能力,来提高程序的整体处理数据的速度。

生产者线程和消费者线程的处理速度差异，会引起消费者想要获取数据时，数据还没生成或者生产者想要交付数据，却没有消费者接收的问题。对于这样的问题，生产者/消费者模型可以消除这个差异。

![1ba205339fae68041077506139839582.png][]

![2e6f3883cae2b78d9c43deb74cc98fc0.png][]

首先，按照注意事项（1）和（2）的要求，定义一个生产者，往队列里添加元素：

// 生产者，有详细的注释
    public class Producer implements Runnable{
        private Queue<Integer> queue;
        private int maxSize;
        public Producer(Queue<Integer> queue, int maxSize){
            this.queue = queue;
            this.maxSize = maxSize;
        }
    
        @Override
        public void run() {
            // 这里为了方便演示做了一个死循环，现实开发中不要这样搞
            while (true){
                //（1）wait()、notify()和notifyAll()必须在synchronized修饰的方法或代码块中使用
                synchronized (queue){
                    //（2）在while循环里而不是if语句下使用wait()，确保在线程睡眠前后都检查wait()触发的条件（防止虚假唤醒）
                    while (queue.size() == maxSize){
                        try{
                            System.out.println("Queue is Full");
                            // 生产者线程进入等待状态，在此对象监视器上等待的所有线程（其实只有那个消费者线程）开始争夺锁
                            queue.wait();
                        }catch (InterruptedException ie){
                            ie.printStackTrace();
                        }
                    }
                    Random random = new Random();
                    int i = random.nextInt();
                    System.out.println("Produce " + i);
                    queue.add(i);
                    // 唤醒这个Queue对象的等待池中的所有线程（其实只有那个消费者线程），等待获取对象监视器
                    queue.notifyAll();
                }
            }
        }
    }

接下来，再定义一个与之类似的消费者类，除了从队列里移除元素的逻辑之外，整体代码大同小异：

// 消费者类
    public class Consumer implements Runnable{
        private Queue<Integer> queue;
        private int maxSize;
        public Consumer(Queue<Integer> queue, int maxSize){
            this.queue = queue;
            this.maxSize = maxSize;
        }
    
        @Override
        public void run() {
            while (true){
                synchronized (queue){
                    while (queue.isEmpty()){
                        System.out.println("Queue is Empty");
                        try{
                            queue.wait();
                        }catch (InterruptedException ie){
                            ie.printStackTrace();
                        }
                    }
                    int v = queue.remove();
                    System.out.println("Consume " + v);
                    queue.notifyAll();
                }
            }
        }
    }

最后编写符合注意事项（3）的测试代码：

public void test(){
        //（3）wait()方法必须在多线程共享的对象上调用
        // 这个队列就是给消费者、生产者两个线程共享的对象
        Queue<Integer> queue = new LinkedList<>();
        int maxSize = 5;
        Producer p = new Producer(queue, maxSize);
        Consumer c = new Consumer(queue, maxSize);
        Thread pT = new Thread(p);
        Thread pC = new Thread(c);
        // 生产者线程启动，获取锁
        pT.start();
        // 消费者线程启动
        pC.start();
    }

最终的查看运行结果如下：

Produce 1604006010
    Produce 1312202442
    Produce -1478853208
    Produce 1460408111
    Produce 1802825495
    Queue is Full
    Consume 1604006010
    Consume 1312202442
    Consume -1478853208
    Consume 1460408111
    Consume 1802825495
    Queue is Empty

![d83ced407a305acd7124346a6e5868dd.png][]

![5c7e1f503cab477563112bcd5f03d4bc.png][]

![c2c55ba7fb98f61f387bb292e0cd77ff.png][]

![d2da53555d106637f486fa38762804df.png][]

![81e86ca1ff46897089b1801eb4e8c80a.png][]

[Object]: http://mp.weixin.qq.com/s?__biz=MzIxMjE5MTE1Nw%3D%3D&chksm=8c986442bbefed542d77cef64d660cdb88c068e7ef6e77960d998aad7bb4933fce48d82d1c7c&idx=1&mid=2653230744&scene=21&sn=f713c92f58d200b1f830cb34381a55de#wechat_redirect
[57d371c95912411b360bda33b79980a7.png]: /images/20220829/f28bdede826449669ac80bcc95010578.png
[7f267204a9bef8354ec7435f0f658388.png]: /images/20220829/9c9846d7080247d4b74c6265181cdf90.png
[4f7a9c9a2599acd5ecc5eb8fce801262.png]: /images/20220829/6c449152e8e74ad7b0f47190f09b60d6.png
[c97eef3f843b851a6e5a096474ba6f89.png]: /images/20220829/cd40cf7eec7d4d1ab502272eb302f8ba.png
[1cfd5e10567546f2d9a1b441e8157a6b.png]: /images/20220829/9829f226092a4e87af229e2060595382.png
[3bbddb0f08d40dad041d1c867a459d13.png]: /images/20220829/db0dcbc7582d411c9d32ce755df6c4af.png
[2dba0f9e8488da877cdef32ba5d0a82d.png]: /images/20220829/b2bc2392a49e417587bb5a6d262d329d.png
[33e9c1a55079a42bac50045b04c68e51.png]: /images/20220829/8dc9d7e6c27341f4a33493c5a86a9ad5.png
[537b71495b41693cbb14e71e02d9995d.png]: /images/20220829/3a0981ff829c4a2a9c8224fec4a730a6.png
[a69c206ade5f97a7a49035ec335588ff.png]: /images/20220829/2d869c91e8084e9c99429fcef33a890f.png
[67a7fd6bf14ea24aca5a934d81459470.png]: /images/20220829/6f39236e07e54105a93f41cad40992b4.png
[653f59c79c45f7f2c8e16613c742249d.png]: /images/20220829/ba4ecd4df2384a948fe244fad82fc7e8.png
[02a03bea1e5f8ca13816786db4338d6a.png]: /images/20220829/1f152cdd3fd849c2a43ca778e13230c5.png
[d524c51564e0239ee5f8197ee3cf5feb.png]: /images/20220829/56a79c56467b437d8924f91ddcd03b12.png
[6798633cad3a1207d352c182ad6cfb7a.png]: /images/20220829/78cd9806be1748679c3e54c2dfa04cdf.png
[94a1b638d689cb76dad4f915beb5b220.png]: /images/20220829/7b37b54910c04c3587a0e9210ac62b6d.png
[80ef89cbe349e78bf0456b2547804c12.png]: /images/20220829/213c16fc47b94f498147258a94d5f15f.png
[ef72d4512c147862fe806a286a410767.png]: /images/20220829/143879e16f694002a614d5a6fc78c747.png
[18c3fbd2e7f6510cd52a8d30b9742007.png]: /images/20220829/142428b32cc849a4b4e73dd6360dda06.png
[bfb5eb7562678698a55b2d132401250e.png]: /images/20220829/9b5e8f3776be46a1a080a5e0608450a4.png
[0a815a0ac82795a1d8b767177281919f.png]: /images/20220829/05e4b1d1aa9c4c8199ce881df44fbf97.png
[511b8a23d17e9d0a51558fffb4681ee6.png]: /images/20220829/73624c925e864340b198092c9ee7d0f0.png
[1ba205339fae68041077506139839582.png]: /images/20220829/05596c3cb5754c6ab5a50c03135651ed.png
[2e6f3883cae2b78d9c43deb74cc98fc0.png]: /images/20220829/72c2e3789f3047f1ba3daccb570b3522.png
[d83ced407a305acd7124346a6e5868dd.png]: /images/20220829/03d9c2c8c2b84e53a1f0c23c557299c6.png
[5c7e1f503cab477563112bcd5f03d4bc.png]: /images/20220829/84ec3fb589af45e285722c93e91da02b.png
[c2c55ba7fb98f61f387bb292e0cd77ff.png]: /images/20220829/724769471ef244a0bdf33a36cf1334eb.png
[d2da53555d106637f486fa38762804df.png]: /images/20220829/54b0ba5f4eb24f11b3414c940478a64f.png
[81e86ca1ff46897089b1801eb4e8c80a.png]: /images/20220829/9df5d2ac693f42e0b1daa2b6ac3529d7.png