Java并发编程之二彻底理解Java的wait和Notify机制

简单介绍

  • wait方法

wait方法的作用是使当前执行代码的线程进行等待，它是Object类的方法，该方法用来将当前线程置入等待队列中，并且在wait所在的代码行处停止执行，直到接到通知或被中断为止。

成都创新互联一直通过网站建设和网站营销帮助企业获得更多客户资源。 以"深度挖掘，量身打造，注重实效"的一站式服务，以成都网站制作、成都做网站、移动互联产品、成都营销网站建设服务为核心业务。10余年网站制作的经验，使用新网站建设技术，全新开发出的标准网站，不但价格便宜而且实用、灵活，特别适合中小公司网站制作。网站管理系统简单易用，维护方便，您可以完全操作网站资料，是中小公司快速网站建设的选择。

该方法只能在同步方法或同步块中调用(即需要先获得对象的监视器锁，一般来说在 synchronized 代码块或者synchronized修饰的方法中使用)，否则抛出异常

IllegalMonitorStateException。

在A线程中调用Lock对象的wait方法以后，会释放Lock对象的监视器锁，同时将A线程放置于Lock对象的等待队列，A线程进入WAITING状态(Thread状态查看系列一)。

  • notify/notifyAll方法

notify/notifyAll方法的作用是唤醒执行对象的等待列表中的一个/所有线程，将其唤醒继续工作。

同样的，notify/notifyAll方法也只能在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的监视器锁。

在B线程中调用Lock对象的notify/notifyAll方法以后，Lock对象等待队列中的A线程从WAITING状态进入BLOCKED状态，而不是直接进入RUNNABLE状态。只有等B线程释放了Lock对象的监视器锁，并且A线程拿到以后，才进入到RUNNABLE状态。所以在编程中，尽量在使用了notify/notifyAll() 后立即释放对象的监视器锁，以便让其他线程获得锁进入RUNNABLE状态。

  • 其他注意事项

wait、notify/notifyAll 方法是Object的本地final方法，无法被重写。

notify 和wait 的顺序不能错，如果A线程先执行notify方法，B线程再执行wait方法，那么B线程是无法被唤醒的。

实例详解

 
 
 
    
  
  
  
  1. public class WaitThread extends Thread { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.     private Object lock; 
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.     public WaitThread(Object lock) { 
    6. 
  
  
  
  6.         this.lock = lock; 
    7. 
  
  
  
  7.     } 
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9.     @Override 
    10. 
  
  
  
  10.     public void run() { 
    11. 
  
  
  
  11.         synchronized (lock) { 
    12. 
  
  
  
  12.             System.out.println("WaitThread开始执行run方法"); 
    13. 
  
  
  
  13.             try { 
    14. 
  
  
  
  14.                 System.out.println("WaitThread开始执行wait方法"); 
    15. 
  
  
  
  15.                 lock.wait(); 
    16. 
  
  
  
  16.                 System.out.println("WaitThread被唤醒"); 
    17. 
  
  
  
  17.             } catch (InterruptedException e) { 
    18. 
  
  
  
  18.                 e.printStackTrace(); 
    19. 
  
  
  
  19.             } 
    20. 
  
  
  
  20.         } 
    21. 
  
  
  
  21.     } 
    22. 
  
  
  
  22. } 
    23. 
 
 
 
 
 
 
    
  
  
  
  1. public class NotifyThread extends Thread { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.     private Object lock; 
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.     public NotifyThread(Object lock) { 
    6. 
  
  
  
  6.         this.lock = lock; 
    7. 
  
  
  
  7.     } 
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9.     @Override 
    10. 
  
  
  
  10.     public void run() { 
    11. 
  
  
  
  11.         System.out.println("NotifyThread开始执行run方法"); 
    12. 
  
  
  
  12.         try { 
    13. 
  
  
  
  13.             System.out.println("NotifyThread睡眠2秒"); 
    14. 
  
  
  
  14.             Thread.sleep(2000); 
    15. 
  
  
  
  15.         } catch (InterruptedException e) { 
    16. 
  
  
  
  16.             e.printStackTrace(); 
    17. 
  
  
  
  17.         } 
    18. 
  
  
  
  18.         synchronized (lock) { 
    19. 
  
  
  
  19.             System.out.println("NotifyThread开始执行notify方法"); 
    20. 
  
  
  
  20.             lock.notify(); 
    21. 
  
  
  
  21.             try { 
    22. 
  
  
  
  22.                 System.out.println("NotifyThread执行notify方法后继续睡眠2秒"); 
    23. 
  
  
  
  23.                 Thread.sleep(2000); 
    24. 
  
  
  
  24.             } catch (InterruptedException e) { 
    25. 
  
  
  
  25.                 e.printStackTrace(); 
    26. 
  
  
  
  26.             } 
    27. 
  
  
  
  27.             System.out.println("NotifyThread睡眠2秒结束，并释放对象监视器锁"); 
    28. 
  
  
  
  28.         } 
    29. 
  
  
  
  29.     } 
    30. 
  
  
  
  30. } 
    31. 
 
 
 
 
 
 
    
  
  
  
  1. public class Main { 
    2. 
  
  
  
  2.     public static void main(String[] args) { 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.         Object lock = new Object(); 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.         // 创建2个线程 
    7. 
  
  
  
  7.         WaitThread waitThread = new WaitThread(lock); 
    8. 
  
  
  
  8.         NotifyThread notifyThread = new NotifyThread(lock); 
    9. 
  
  
  
  9.         // 启动他们 
    10. 
  
  
  
  10.         waitThread.start(); 
    11. 
  
  
  
  11.         notifyThread.start(); 
    12. 
  
  
  
  12.     } 
    13. 
  
  
  
  13. } 
    14. 
 
 
 
 
 
 
    
  
  
  
  1. NotifyThread开始执行run方法 
    2. 
  
  
  
  2. WaitThread开始执行run方法 
    3. 
  
  
  
  3. WaitThread开始执行wait方法 
    4. 
  
  
  
  4. NotifyThread睡眠2秒 
    5. 
  
  
  
  5. NotifyThread开始执行notify方法 
    6. 
  
  
  
  6. NotifyThread执行notify方法后继续睡眠2秒 
    7. 
  
  
  
  7. NotifyThread睡眠2秒结束，并释放对象监视器锁 
    8. 
  
  
  
  8. WaitThread被唤醒 
    9.

WaitThread在拿到lock的监视器锁以后调用wait方法。

NotifyThread在启动以后先睡眠2秒，保证了notify方法在wait方法后面。

NotifyThread执行notify方法后继续睡眠2秒，这个时候NotifyThread并没有释放Lock的监视器锁，因此WaitThread处于BLOCKED状态并没有被真正被唤醒。

NotifyThread睡眠2秒结束，并释放对象监视器锁，这个时候NotifyThread取到Lock的监视器锁并进入到RUNNABLE状态。

进阶思考

如果A线程获得了多个对象的监视器锁，然后调用其中1个对象的wait方法，是释放所有对象的锁还是只释放调用的那个对象的锁呢?

我们一起通过一个示例来进行一下测试。

 
 
 
    
  
  
  
  1. public class WaitThread extends Thread { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.     private Object lock; 
    4. 
  
  
  
  4.     private Object other; 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.     public WaitThread(Object lock, Object other) { 
    7. 
  
  
  
  7.         this.lock = lock; 
    8. 
  
  
  
  8.         this.other = other; 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11.     @Override 
    12. 
  
  
  
  12.     public void run() { 
    13. 
  
  
  
  13.         synchronized (lock) { 
    14. 
  
  
  
  14.             synchronized (other) { 
    15. 
  
  
  
  15.                 System.out.println("WaitThread开始执行run方法"); 
    16. 
  
  
  
  16.                 try { 
    17. 
  
  
  
  17.                     System.out.println("WaitThread开始执行wait方法"); 
    18. 
  
  
  
  18.                     lock.wait(); 
    19. 
  
  
  
  19.                     System.out.println("WaitThread被唤醒"); 
    20. 
  
  
  
  20.                 } catch (InterruptedException e) { 
    21. 
  
  
  
  21.                     e.printStackTrace(); 
    22. 
  
  
  
  22.                 } 
    23. 
  
  
  
  23.             } 
    24. 
  
  
  
  24.         } 
    25. 
  
  
  
  25.     } 
    26. 
  
  
  
  26. } 
    27. 
 
 
 
 
 
 
    
  
  
  
  1. public class NotifyThread extends Thread { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.     private Object lock; 
    4. 
  
  
  
  4.     private Object other; 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.     public NotifyThread(Object lock, Object other) { 
    7. 
  
  
  
  7.         this.lock = lock; 
    8. 
  
  
  
  8.         this.other = other; 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11.     @Override 
    12. 
  
  
  
  12.     public void run() { 
    13. 
  
  
  
  13.         System.out.println("NotifyThread开始执行run方法"); 
    14. 
  
  
  
  14.         try { 
    15. 
  
  
  
  15.             System.out.println("NotifyThread睡眠2秒"); 
    16. 
  
  
  
  16.             Thread.sleep(2000); 
    17. 
  
  
  
  17.         } catch (InterruptedException e) { 
    18. 
  
  
  
  18.             e.printStackTrace(); 
    19. 
  
  
  
  19.         } 
    20. 
  
  
  
  20.         synchronized (lock) { 
    21. 
  
  
  
  21.             System.out.println("NotifyThread获得lock锁"); 
    22. 
  
  
  
  22.  
    23. 
  
  
  
  23.             synchronized (other) { 
    24. 
  
  
  
  24.                 System.out.println("NotifyThread获得other锁"); 
    25. 
  
  
  
  25.                 System.out.println("NotifyThread开始执行notify方法"); 
    26. 
  
  
  
  26.                 lock.notify(); 
    27. 
  
  
  
  27.                 try { 
    28. 
  
  
  
  28.                     System.out.println("NotifyThread执行notify方法后继续睡眠2秒"); 
    29. 
  
  
  
  29.                     Thread.sleep(2000); 
    30. 
  
  
  
  30.                 } catch (InterruptedException e) { 
    31. 
  
  
  
  31.                     e.printStackTrace(); 
    32. 
  
  
  
  32.                 } 
    33. 
  
  
  
  33.                 System.out.println("NotifyThread睡眠2秒结束，并释放对象监视器锁"); 
    34. 
  
  
  
  34.             } 
    35. 
  
  
  
  35.         } 
    36. 
  
  
  
  36.     } 
    37. 
  
  
  
  37. } 
    38. 
 
 
 
 
 
 
    
  
  
  
  1. public class Main { 
    2. 
  
  
  
  2.     public static void main(String[] args) { 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.         Object lock = new Object(); 
    5. 
  
  
  
  5.         Object other = new Object(); 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7.         // 创建2个线程 
    8. 
  
  
  
  8.         WaitThread waitThread = new WaitThread(lock, other); 
    9. 
  
  
  
  9.         NotifyThread notifyThread = new NotifyThread(lock, other); 
    10. 
  
  
  
  10.         // 启动他们 
    11. 
  
  
  
  11.         waitThread.start(); 
    12. 
  
  
  
  12.         notifyThread.start(); 
    13. 
  
  
  
  13.     } 
    14. 
  
  
  
  14. } 
    15. 
 
 
 
 
 
 
    
  
  
  
  1. WaitThread开始执行run方法 
    2. 
  
  
  
  2. WaitThread开始执行wait方法 
    3. 
  
  
  
  3. NotifyThread开始执行run方法 
    4. 
  
  
  
  4. NotifyThread睡眠2秒 
    5. 
  
  
  
  5. NotifyThread获得lock锁 
    6.

WaitThread线程拿到lock和other的对象锁以后，执行了lock的wait方法。NotifyThread线程在睡眠2秒后，仅拿到了lock锁，说明wait方法只释放了被执行对应的锁，这样就造成了死锁。

因此如果使用wait和notify机制时，一定要确认Wait线程和Notify线程获取对象锁的情况，尽量避免在获取多个对象锁的情况下使用，防止造成死锁问题。

文章标题：Java并发编程之二彻底理解Java的wait和Notify机制
URL链接：http://www.mswzjz.cn/qtweb/news18/64218.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

网站维护知识

同城分类信息

手机微信网站　　 　成都网站运维　　 　专业LED亮化工程　　 　全网整合营销推广　　 　迷你发光字　　 　成都app软件开发公司　　 　阿坝网站设计　　 　成都展柜制作　　 　设计网站　　 　网站SEO优化排名　　 　成都宣传画册设计　　 　成都虚拟主机　　 　温江做网站公司　　 　温江网站设计　　 　简阳做网站　　 　四川服务器托管　　 　达州网站建设　　 　成都网页制作　　 　广汉锦华橡塑　　 　力比特机械