java线程之等待/通知机制

你的名字 2022-01-29 15:11 234阅读 0赞

# 等待通知机制 #

一个线程修改了对象的值，而另一个线程感知了变化并进行相应操作，整个过程开始于一个线程而最终执行又是另一个线程。前者是生产者，后者是消费者，这种模式隔离了“做什么”和“怎么做”，在功能层面上实现了解耦，体系结构上具有良好的伸缩性。在java语言中如何实现呢?

# 示例 #

简单的方法就是让消费者线程不断地检查变量是否符合预期，如下面代码所示，在while循环中设置不满足的条件，一旦满足条件从而推出while循环，从而完成消费者的工作。

while (value != desire) {
    	Thread.sleep(1000);
    }
     doSomething();

上面这段伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的“无效”尝试，这种方式看似能够解实现所需的功能，但是却存在如下问题。  
1）难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。  
2）难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。  
以上两个问题，看似矛盾难以调和，但是Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。  
等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类java.lang.Object上，方法和描述如图所示。  
等待/通知的相关方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjU0ODQx_size_16_color_FFFFFF_t_70]等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。  
示例：  
Things.java

public class Things {
        private boolean flag;
    
        public boolean isFlag() {
            return flag;
        }
    
        public void setFlag(boolean flag) {
            this.flag = flag;
        }
    }

WaitThread.java

public class WaitThread implements Runnable {
        private Things lock;
    
        public WaitThread(Things lock) {
            this.lock = lock;
        }
    
        @Override
        public void run() {
           //获取锁
            synchronized (lock){
                //flag 为true时，继续wait，同时释放了lock锁
                while (lock.isFlag()){
                    System.out.println("WaitThread is waiting , time is "+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
                System.out.println(Thread.currentThread() + " flag is false. running @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }

NotifyThread.java

public class NotifyThread implements Runnable {
        private Things lock;
    
        public NotifyThread(Things lock) {
            this.lock = lock;
        }
    
        @Override
        public void run() {
            //加锁
            synchronized (lock) {
            //获取当前lock的锁，然后进行通知，通知时不会释放锁
            //直到当前线程释放了lock锁，waitThread才能从wait方法中返回
                System.out.println("NotifyThread is holding lock , time is " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                lock.notifyAll();
                lock.setFlag(false);
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            再次获取锁
            synchronized (lock) {
                System.out.println("NotifyThread is holding lock again, time is " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

WN.java 主函数

public class Wn {
        public static void main(String[] args) {
            Things things = new Things();
            things.setFlag(true);
            new Thread(new WaitThread(things)).start();
    
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            new Thread(new NotifyThread(things)).start();
        }
    }

输出结果如下：

Thread[WaitThread,5,main] flag is true. wait@ 21:33:39
    Thread[NotifyThread,5,main] hold lock. notify @ 21:33:40
    Thread[NotifyThread,5,main] hold lock again. sleep @ 21:33:45
    Thread[WaitThread,5,main] flag is false. running @ 21:33:50

上述第3行和第4行输出的顺序可能会互换，而上述例子主要说明了调用wait()、notify()以及notifyAll()时需要注意的细节，如下。  
1）使用wait()、notify()和notifyAll()时需要先对调用对象加锁。  
2）调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。  
3）notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。  
4）notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。  
5）从wait()方法返回的前提是获得了调用对象的锁。  
从上述细节中可以看到，等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。  
上述示例的过程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjU0ODQx_size_16_color_FFFFFF_t_70 1]WaitThread首先获取了对象的锁，然后调用对象的wait()方法，从而放弃了锁  
并进入了对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notify()方法，将WaitThread从WaitQueue移到SynchronizedQueue中，此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行。

# 等待/通知的经典范式 #

示例中可以提炼出等待/通知的经典范式，该范式分为两部分，分  
别针对等待方（消费者）和通知方（生产者）。  
等待方遵循如下原则。  
1）获取对象的锁。  
2）如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。  
3）条件满足则执行对应的逻辑。  
对应的伪代码如下。  
synchronized(对象) \{  
while(条件不满足) \{  
对象.wait();  
\}  
对应的处理逻辑  
\}

通知方遵循如下原则。  
1）获得对象的锁。  
2）改变条件。  
3）通知所有等待在对象上的线程。  
对应的伪代码如下。  
synchronized(对象) \{  
改变条件  
对象.notifyAll();  
\}

本文参考《java并发编程的艺术》  
了解多线程基础可查看：[https://blog.csdn.net/qq\_39654841/article/details/87868135][https_blog.csdn.net_qq_39654841_article_details_87868135]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjU0ODQx_size_16_color_FFFFFF_t_70]: /images/20220129/065d9a13f9884ac1be2512563e1f9f71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjU0ODQx_size_16_color_FFFFFF_t_70 1]: /images/20220129/ba176433683c4a7fa79fd4f335f07cd4.png
[https_blog.csdn.net_qq_39654841_article_details_87868135]: https://blog.csdn.net/qq_39654841/article/details/87868135