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机制
文章转载：http://www.hantingmc.com/qtweb/news18/64218.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

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

猜你还喜欢下面的内容

企业建站知识

同城分类信息

平昌做网站　　 　成都网站制作　　 　免备案空间　　 　机柜租用　　 　成都网站设计　　 　做网站　　 　成都外贸网站优化　　 　成都LED显示屏　　 　重庆主机托管　　 　成都APP定制开发　　 　微信公众号开发　　 　品牌网站建设　　 　成都租用服务器　　 　背发光字　　 　平昌保洁　　 　网站建设策划方案　　 　成都创新互联　　 　重庆服务器托管　　 　php空间　　 　3D立体画