Java并发--监视器（monitor）、等待/通知机制

男娘i 2021-08-13 21:15 543阅读 0赞

### Monitor？ ###

*  Monitor是一种用来实现同步的工具
 *  与每个java对象相关联，即每个java对象都有一个Monitor与之对应
 *  Monitor是实现Sychronized(内置锁)的基础

### Monitor的基本结构 ###

*  **Owner字段：** 初始时为NULL表示当前没有任何线程拥有该monitor record，当线程成功拥有该锁后保存线程唯一标识，当锁被释放时又设置为NULL
 *  **EntryQ字段：** 关联一个系统互斥锁（semaphore），阻塞所有试图锁住monitor record失败的线程
 *  **RcThis字段：** 表示blocked或waiting在该monitor record上的所有线程的个数
 *  **Nest字段：** 用来实现重入锁的计数
 *  **HashCode字段**： 保存从对象头拷贝过来的HashCode值（可能还包含GC age）
 *  **Candidate字段：** 用来避免不必要的阻塞或等待线程唤醒，因为每一次只有一个线程能够成功拥有锁，如果每次前一个释放锁的线程唤醒所有正在阻塞或等待的线程，会引起不必要的上下文切换（从阻塞到就绪然后因为竞争锁失败又被阻塞）从而导致性能严重下降；Candidate只有两种可能的值0表示没有需要唤醒的线程1表示要唤醒一个继任线程来竞争锁。

Monitor与java对象以及线程是如何关联的

*  如果一个java对象被某个线程锁住，则该java对象的Mark Word字段中LockWord指向monitor的起始地址
 *  Monitor的Owner字段会存放拥有相关联对象锁的线程id

### 方法 ###

*  Monitor的enter方法：获取锁
 *  Monitor的exit方法：释放锁
 *  Monitor的wait方法：为java的Object的wait方法提供支持
 *  Monitor的notify方法：为java的Object的notify方法提供支持
 *  Monitor的notifyAll方法：为java的Object的notifyAll方法提供支持

任意一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方的线程必须先获取到该对象的监视器才能进入同步块或者同步方法，而没有获取到监视器（执行该方法）的线程将会被阻塞在同步块和同步方法的入口处，进入BLOCKED状态。

对象、监视器、同步队列和执行线程之间的关系  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]

从图中可以看到，任意线程对Object（Object由synchronized保护）的访问，首先要获得Object的监视器。如果获取失败，线程进入同步队列，线程状态变为BLOCKED。当访问Object的前驱（获得了锁的线程）释放了锁，则该释放操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。

### 等待/通知机制 ###

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

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

![在这里插入图片描述][2020011919490968.png]

上面这段伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的“无效”尝试，这种方式看似能够解实现所需的功能，但是却存在如下问题。

*  难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
 *  难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。以上两个问题，看似矛盾难以调和，但是Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。

等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类java.lang.Object上，方法和描述如下表所示。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 1]

等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

示例：

package pers.zhang.part4;
    
    import javax.sound.midi.Soundbank;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.TimeUnit;
    
    /** * @author zhang * @date 2020/1/19 - 19:51 * * 等待/通知机制 */
    public class WaitNotify { 
    
        static boolean flag = true;
        static Object lock = new Object();
    
        public static void main(String[] args) throws InterruptedException { 
            Thread waitThread = new Thread(new Wait(), "WaitThread");
            waitThread.start();
            TimeUnit.SECONDS.sleep(1);
            Thread notifyThread = new Thread(new Notify(), "NotifyThread");
            notifyThread.start();
        }
    
    
        static class Wait implements Runnable{ 
    
            @Override
            public void run() { 
                //加锁，拥有lock的Monitor
                synchronized (lock){ 
                    //当条件不满足时，继续wait，同时释放了lock锁
                    while (flag){ 
                        System.out.println(Thread.currentThread() + " flag is true. wait@ " + new SimpleDateFormat("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()));
                }
            }
        }
    
    
        static class Notify implements Runnable{ 
    
            @Override
            public void run() { 
                //加锁，拥有lock的Monitor
                synchronized (lock){ 
                    //获取lock的锁然后进行通知，通知时不会释放lock的锁
                    //直到当前线程释放了lock后，WaitThread才能从wait方法中返回
                    System.out.println(Thread.currentThread() + " hold lock. notify@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    lock.notifyAll();
                    flag = false;
                    SleepUtils.second(5);
                }
                //再次加锁
                synchronized (lock){ 
                    System.out.println(Thread.currentThread() + " hold lock again. sleep@ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    SleepUtils.second(5);
                }
            }
        }
    
    }

输出如下：第3行和第4行可能顺序调换

Thread[WaitThread,5,main] flag is true. wait@ 20:02:52
    Thread[NotifyThread,5,main] hold lock. notify@ 20:02:53
    Thread[NotifyThread,5,main] hold lock again. sleep@ 20:02:58
    Thread[WaitThread,5,main] flag is false. running@ 20:03:03

上述例子主要说明了调用wait()、notify()以及notifyAll()时需要注意的细节，如下。

*  使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
 *  调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
 *  notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。
 *  notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
 *  从wait()方法返回的前提是获得了调用对象的锁。

从上述细节中可以看到，等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 2]

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();
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70]: /images/20210813/132af4668d82428abfc3fd13dd0677ea.png
[2020011919490968.png]: /images/20210813/5806d150f06b4aa39d54bd48170007d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 1]: /images/20210813/376b33196c504a51a18a314a1e1c547b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvbGRfX19wbGF5_size_16_color_FFFFFF_t_70 2]: /images/20210813/04eaa3ae1360497d81667c8f090f5b31.png