本文共 5270 字,大约阅读时间需要 17 分钟。
Monitor与java对象以及线程是如何关联的
任意一个对象都拥有自己的监视器,当这个对象由同步块或者这个对象的同步方法调用时,执行方的线程必须先获取到该对象的监视器才能进入同步块或者同步方法,而没有获取到监视器(执行该方法)的线程将会被阻塞在同步块和同步方法的入口处,进入BLOCKED状态。
对象、监视器、同步队列和执行线程之间的关系
从图中可以看到,任意线程对Object(Object由synchronized保护)的访问,首先要获得Object的监视器。如果获取失败,线程进入同步队列,线程状态变为BLOCKED。当访问Object的前驱(获得了锁的线程)释放了锁,则该释放操作唤醒阻塞在同步队列中的线程,使其重新尝试对监视器的获取。
一个线程修改了一个对象的值,而另一个线程感知到了变化,然后进行相应的操作,整个过程开始于一个线程,而最终执行又是另一个线程。前者是生产者,后者就是消费者,这种模式隔离了“做什么”(what)和“怎么做”(How),在功能层面上实现了解耦,体系结构上具备了良好的伸缩性,但是在Java语言中如何实现类似的功能呢?
简单的办法是让消费者线程不断地循环检查变量是否符合预期,如下面代码所示,在while循环中设置不满足的条件,如果条件满足则退出while循环,从而完成消费者的工作。
上面这段伪代码在条件不满足时就睡眠一段时间,这样做的目的是防止过快的“无效”尝试,这种方式看似能够解实现所需的功能,但是却存在如下问题。
等待/通知的相关方法是任意Java对象都具备的,因为这些方法被定义在所有对象的超类java.lang.Object上,方法和描述如下表所示。
等待/通知机制,是指一个线程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:52Thread[NotifyThread,5,main] hold lock. notify@ 20:02:53Thread[NotifyThread,5,main] hold lock again. sleep@ 20:02:58Thread[WaitThread,5,main] flag is false. running@ 20:03:03
上述例子主要说明了调用wait()、notify()以及notifyAll()时需要注意的细节,如下。
从上述细节中可以看到,等待/通知机制依托于同步机制,其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。
WaitThread首先获取了对象的锁,然后调用对象的wait()方法,从而放弃了锁并进入了对象的等待队列WaitQueue中,进入等待状态。由于WaitThread释放了对象的锁,NotifyThread随后获取了对象的锁,并调用对象的notify()方法,将WaitThread从WaitQueue移到SynchronizedQueue中,此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后,WaitThread再次获取到锁并从wait()方法返回继续执行。
该范式分为两部分,分别针对等待方(消费者)和通知方(生产者)。
等待方遵循如下原则
对应的伪代码如下:
synchronized(对象){ while(条件不足){ 对象.wait(); } 对应的处理逻辑}
通知方遵循如下原则
对应的伪代码如下:
synchronized(对象){ 改变条件 对象.notifyAll();}
转载地址:http://wfpqb.baihongyu.com/