线程等待通知机制

阳光穿透心脏的1/2处 2022-05-19 07:49 197阅读 0赞

等待通知机制，是指一个线程A调用了对象O的wait方法进入等待状态，而另一个线程调用了对象O的notify或者notifyAll方法，线程A收到通知后从对象O的wait方法返回，进而执行后续操作

<table> 
 <tbody> 
  <tr> 
   <td style="width:198px;">方法名称</td> 
   <td style="width:680px;">描述</td> 
  </tr> 
  <tr> 
   <td style="width:198px;">notify()</td> 
   <td style="width:680px;">通知一个在对象上对待的线程，使其从wait方法返回，而返回的前提是该线程获取到了对象的锁</td> 
  </tr> 
  <tr> 
   <td style="width:198px;">notifyAll()</td> 
   <td style="width:680px;">通知所有等待在该对象上的线程</td> 
  </tr> 
  <tr> 
   <td style="width:198px;">wait()</td> 
   <td style="width:680px;">调用该方法的线程进入WAITING状态，只有等待另一个线程的通知或中断才会被返回，需要注意，调用wait方法后，会释放对象锁</td> 
  </tr> 
  <tr> 
   <td style="width:198px;">wait(long)</td> 
   <td style="width:680px;">超时等待一段时间，这里参数时间是毫秒，如果没有通知就超时返回</td> 
  </tr> 
  <tr> 
   <td style="width:198px;">wait(long,int)</td> 
   <td style="width:680px;">对于超时时间更细粒度的控制，可以达到纳秒</td> 
  </tr> 
 </tbody> 
</table>

代码示例

package com.demo.demo4;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class WaitNotify {
    
    	static boolean flag = true;
    
    	static Object lock = new Object();
    
    	public static void main(String[] args) {
    
    		Thread waitThread = new Thread(new Wait(),"waitThread");
    		waitThread.start();
    		try {
    			Thread.sleep(1);
    			Thread notifyThread = new Thread(new Notify(),"notifyThread");
    			notifyThread.start();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    	static class Wait implements Runnable{
    
    		@Override
    		public void run() {
    			//加锁，拥有lock的Monitor
    			synchronized(lock) {
    				//当条件不满足，继续wait，同时释放了lock的锁
    				while(flag) {
    					try {
    						System.out.println(Thread.currentThread()+"flag is true.wait@"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
    						lock.wait();
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    				//满足条件，完成工作
    				System.out.println(Thread.currentThread()+"flag is false.wait@"+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.nofity @"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    lock.notifyAll();
                    flag = true;
                    try {
    					Thread.sleep(5);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}	
    			//在此加锁
    			synchronized(lock) {
    				System.out.println(Thread.currentThread()+"hold lock.nofity @"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    try {
    					Thread.sleep(5);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    
    	}
    }

一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行的又是另一个线程

1、使用wait(),notify()和notifyAll()时需要先调用对象的锁

2、调用wait方法后，线程状态由RUNING变为WAITING，并将当前线程放置到对象的等待队列

3、notify()和notifyAll()方法调用后，等待线程依旧不会从wait返回，需要调用notify()和notifyAll()线程释放锁之后，等待线程才有机会从wait()返回

4、notify()方法将等待队列中的一个线程从等待队列中移动到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列中，被移动的队列线程状态由WAITING变为BLOCKED

5、从wait()方法返回的前提就是获取了调用的对象的锁