Java多线程中的wait()，notify()和sleep()

其他 2018-10-12 00:04:47 阅读次数: 0

wait()和sleep()

我们先简单的了解一下wait()和sleep()这两个方法：

首先wait()是属于Object类的方法，从源码给出的解释来看，wait()方法可以做到如下几点：

（1）首先，调用了wait()之后会引起当前线程处于等待状状态。

（2）其次，每个线程必须持有该对象的monitor。如果在当前线程中调用wait()方法之后，该线程就会释放monitor的持有对象并让自己处于等待状态。

（3）如果想唤醒一个正在等待的线程，那么需要开启一个线程通过notify()或者notifyAll()方法去通知正在等待的线程获取monitor对象。如此，该线程即可打破等待的状态继续执行代码。

  1. /**
  2. * Causes the current thread to wait until another thread invokes the
  3. * {@link java.lang.Object#notify()} method or the
  4. * {@link java.lang.Object#notifyAll()} method for this object.
  5. * In other words, this method behaves exactly as if it simply
  6. * performs the call {@code wait(0)}.
  7. * <p>
  8. * The current thread must own this object's monitor. The thread
  9. * releases ownership of this monitor and waits until another thread
  10. * notifies threads waiting on this object's monitor to wake up
  11. * either through a call to the {@code notify} method or the
  12. * {@code notifyAll} method. The thread then waits until it can
  13. * re-obtain ownership of the monitor and resumes execution.
  14. * <p>
  15. * As in the one argument version, interrupts and spurious wakeups are
  16. * possible, and this method should always be used in a loop:
  17. * <pre>
  18. * synchronized (obj) {
  19. * while (<condition does not hold>)
  20. * obj.wait();
  21. * ... // Perform action appropriate to condition
  22. * }
  23. * </pre>
  24. * This method should only be called by a thread that is the owner
  25. * of this object's monitor. See the {@code notify} method for a
  26. * description of the ways in which a thread can become the owner of
  27. * a monitor.
  28. *
  29. * @exception IllegalMonitorStateException if the current thread is not
  30. * the owner of the object's monitor.
  31. * @exception InterruptedException if any thread interrupted the
  32. * current thread before or while the current thread
  33. * was waiting for a notification. The <i>interrupted
  34. * status</i> of the current thread is cleared when
  35. * this exception is thrown.
  36. * @see java.lang.Object#notify()
  37. * @see java.lang.Object#notifyAll()
  38. */
  39. public final void wait() throws InterruptedException {
  40. wait( 0);
  41. }

代码演示：

  1. public class Main {
  2. public static void main(String[] args) {
  3. Main main = new Main();
  4. main.startThread();
  5. }
  7. /**
  8. * 线程锁
  9. */
  10. private final Object object = new Object();
  12. /**
  13. * 启动线程
  14. */
  15. public void startThread() {
  16. Thread t = new Thread( new Runnable() {
  17. @Override
  18. public void run() {
  19. System.out.println( "开始执行线程。。。");
  20. System.out.println( "进入等待状态。。。");
  21. synchronized (object) {
  22. try {
  23. object.wait();
  24. } catch (InterruptedException e) {
  25. e.printStackTrace();
  26. }
  27. }
  28. System.out.println( "线程结束。。。");
  29. }
  30. });
  31. t.start();
  32. }
  33. }

从代码来看，在执行线程和线程结束之间，我们先让该线程获取object对象作为自己的object's monitor，然后调用了object对象的wait()方法从而让其进入等待状态。那么程序运行的结果如下：


程序在未被唤醒之后，将不再打印“线程结束”，并且程序无法执行完毕一直处于等待状态。


sleep()方法来自于Thread类，从源码给出的解释来看，sleep()方法可以做到如下几点：

（1）首先，调用sleep()之后，会引起当前执行的线程进入暂时中断状态，也即睡眠状态。

（2）其次，虽然当前线程进入了睡眠状态，但是依然持有monitor对象。

（3）在中断完成之后，自动进入唤醒状态从而继续执行代码。

  1. /**
  2. * Causes the currently executing thread to sleep (temporarily cease
  3. * execution) for the specified number of milliseconds, subject to
  4. * the precision and accuracy of system timers and schedulers. The thread
  5. * does not lose ownership of any monitors.
  6. *
  7. * @param millis
  8. * the length of time to sleep in milliseconds
  9. *
  10. * @throws IllegalArgumentException
  11. * if the value of {@code millis} is negative
  12. *
  13. * @throws InterruptedException
  14. * if any thread has interrupted the current thread. The
  15. * <i>interrupted status</i> of the current thread is
  16. * cleared when this exception is thrown.
  17. */
  18. public static native void sleep(long millis) throws InterruptedException;


代码演示：

  1. public class Main {
  2. public static void main(String[] args) {
  3. Main main = new Main();
  4. main.startThread();
  5. }
  7. /**
  8. * 启动线程
  9. */
  10. public void startThread() {
  11. Thread t = new Thread( new Runnable() {
  12. @Override
  13. public void run() {
  14. System.out.println( "开始执行线程。。。");
  15. System.out.println( "进入睡眠状态。。。");
  16. try {
  17. Thread.sleep( 3000);
  18. } catch (InterruptedException e) {
  19. e.printStackTrace();
  20. }
  21. System.out.println( "线程结束。。。");
  22. }
  23. });
  24. t.start();
  25. }
  26. }

从运行的结果来看，我们可以看出程序虽然在运行过程中中断了3秒，但是在3秒结束之后依然会继续执行代码，直到运行结束。在睡眠的期间内，线程会一直持有monitor对象。



那么从以上的理论和实践来分析，我们能得出如下结论：

（1）在线程的运行过程中，调用该线程持有monitor对象的wait()方法时，该线程首先会进入等待状态，并将自己持有的monitor对象释放。

（2）如果一个线程正处于等待状态时，那么唤醒它的办法就是开启一个新的线程，通过notify()或者notifyAll()的方式去唤醒。当然，需要注意的一点就是，必须是同一个monitor对象。

（3）sleep()方法虽然会使线程中断，但是不会将自己的monitor对象释放，在中断结束后，依然能够保持代码继续执行。


notify()和notifyAll()

说完了wait()方法之后，我们接下来讨论一下Object类中的另外两个与wait()相关的方法。首先还是通过源码的方式让大家先初步了解一下：
  1. /**
  2. * Wakes up a single thread that is waiting on this object's
  3. * monitor. If any threads are waiting on this object, one of them
  4. * is chosen to be awakened. The choice is arbitrary and occurs at
  5. * the discretion of the implementation. A thread waits on an object's
  6. * monitor by calling one of the {@code wait} methods.
  7. * <p>
  8. * The awakened thread will not be able to proceed until the current
  9. * thread relinquishes the lock on this object. The awakened thread will
  10. * compete in the usual manner with any other threads that might be
  11. * actively competing to synchronize on this object; for example, the
  12. * awakened thread enjoys no reliable privilege or disadvantage in being
  13. * the next thread to lock this object.
  14. * <p>
  15. * This method should only be called by a thread that is the owner
  16. * of this object's monitor. A thread becomes the owner of the
  17. * object's monitor in one of three ways:
  18. * <ul>
  19. * <li>By executing a synchronized instance method of that object.
  20. * <li>By executing the body of a {@code synchronized} statement
  21. * that synchronizes on the object.
  22. * <li>For objects of type {@code Class,} by executing a
  23. * synchronized static method of that class.
  24. * </ul>
  25. * <p>
  26. * Only one thread at a time can own an object's monitor.
  27. *
  28. * @exception IllegalMonitorStateException if the current thread is not
  29. * the owner of this object's monitor.
  30. * @see java.lang.Object#notifyAll()
  31. * @see java.lang.Object#wait()
  32. */
  33. public final native void notify();
先来看下notify()这个方法，通过阅读源码我们可以总结一下几点：
（1）当一个线程处于wait()状态时，也即等待它之前所持有的object's monitor被释放，通过notify()方法可以让该线程重新处于活动状态，从而去抢夺object's monitor，唤醒该线程。
（2）如果多个线程同时处于等待状态，那么调用notify()方法只能随机唤醒一个线程。
（3）在同一时间内，只有一个线程能够获得object's monitor，执行完毕之后，则再将其释放供其它线程抢占。
当然，如何使线程成为object‘s monitor的持有者，我会在多线程的其他博客中讲解。

接下来，我们再来看看notifyAll()方法：
  1. /**
  2. * Wakes up all threads that are waiting on this object's monitor. A
  3. * thread waits on an object's monitor by calling one of the
  4. * {@code wait} methods.
  5. * <p>
  6. * The awakened threads will not be able to proceed until the current
  7. * thread relinquishes the lock on this object. The awakened threads
  8. * will compete in the usual manner with any other threads that might
  9. * be actively competing to synchronize on this object; for example,
  10. * the awakened threads enjoy no reliable privilege or disadvantage in
  11. * being the next thread to lock this object.
  12. * <p>
  13. * This method should only be called by a thread that is the owner
  14. * of this object's monitor. See the {@code notify} method for a
  15. * description of the ways in which a thread can become the owner of
  16. * a monitor.
  17. *
  18. * @exception IllegalMonitorStateException if the current thread is not
  19. * the owner of this object's monitor.
  20. * @see java.lang.Object#notify()
  21. * @see java.lang.Object#wait()
  22. */
  23. public final native void notifyAll();
那么顾名思义，notifyAll()就是用来唤醒正在等待状态中的所有线程的，不过也需要注意以下几点：
（1）notifyAll()只会唤醒那些等待抢占指定object's monitor的线程，其他线程则不会被唤醒。
（2）notifyAll()只会一个一个的唤醒，而并非统一唤醒。因为在同一时间内，只有一个线程能够持有object's monitor
（3）notifyAll()只是随机的唤醒线程，并非有序唤醒。
那么如何做到有序唤醒是我们接下来要讨论的问题。

notify()实现有序唤醒的思路和实现

就上节提出的问题，我们在这节中可以进行一下思考和讨论。
首先，简单来说，我们需要去解决的其实就是对于多线程针对object's monitor的有序化。那么根据这一思路，我直接上代码：
  1. public class MyThreadFactory {
  3. // 线程A是否处于等待状态的标志
  4. private boolean isThreadAWaiting;
  5. // 线程B是否处于等待状态的标志
  6. private boolean isThreadBWaiting;
  7. // 线程C是否处于等待状态的标志
  8. private boolean isThreadCWaiting;
  10. public MyThreadFactory() {
  11. isThreadAWaiting = true;
  12. isThreadBWaiting = true;
  13. isThreadCWaiting = true;
  14. }
  16. /**
  17. * 对象锁
  18. */
  19. private final Object object = new Object();
  21. /**
  22. * 该线程作为一个唤醒线程
  23. */
  24. public void startWakenThread() {
  25. Thread t = new Thread( new Runnable() {
  26. @Override
  27. public void run() {
  28. synchronized (object) {
  29. System.out.println( "唤醒线程开始执行...");
  30. // 首先释放线程A
  31. quitThreadA();
  32. }
  33. }
  34. });
  35. t.start();
  36. }
  38. /**
  39. * 启动线程A
  40. */
  41. public void startThreadA() {
  42. Thread t = new Thread( new Runnable() {
  43. @Override
  44. public void run() {
  45. synchronized (object) {
  46. System.out.println( "线程A开始等待...");
  47. try {
  48. for (; ; ) {
  49. if (!isThreadAWaiting) break;
  50. object.wait();
  51. }
  52. } catch (InterruptedException e) {
  53. e.printStackTrace();
  54. }
  55. System.out.println( "线程A结束...");
  56. // 线程A结束后，暂停2秒释放线程B
  57. try {
  58. Thread.sleep( 2000);
  59. } catch (InterruptedException e) {
  60. e.printStackTrace();
  61. }
  62. quitThreadB();
  63. }
  64. }
  65. });
  66. t.start();
  67. }
  69. /**
  70. * 启动线程B
  71. */
  72. public void startThreadB() {
  73. Thread t = new Thread( new Runnable() {
  74. @Override
  75. public void run() {
  76. synchronized (object) {
  77. System.out.println( "线程B开始等待...");
  78. try {
  79. for (; ; ) {
  80. if (!isThreadBWaiting) break;
  81. object.wait();
  82. }
  83. } catch (InterruptedException e) {
  84. e.printStackTrace();
  85. }
  86. System.out.println( "线程B结束...");
  87. // 线程B结束后，暂停2秒释放线程C
  88. try {
  89. Thread.sleep( 2000);
  90. } catch (InterruptedException e) {
  91. e.printStackTrace();
  92. }
  93. quitThreadC();
  94. }
  95. }
  96. });
  97. t.start();
  98. }
  100. /**
  101. * 启动线程C
  102. */
  103. public void startThreadC() {
  104. Thread t = new Thread( new Runnable() {
  105. @Override
  106. public void run() {
  107. synchronized (object) {
  108. System.out.println( "线程C开始等待...");
  109. try {
  110. for (; ; ) {
  111. if (!isThreadCWaiting) break;
  112. object.wait();
  113. }
  114. } catch (InterruptedException e) {
  115. e.printStackTrace();
  116. }
  117. System.out.println( "线程C结束...");
  119. try {
  120. Thread.sleep( 1000);
  121. } catch (InterruptedException e) {
  122. e.printStackTrace();
  123. }
  124. System.out.println( "所有线程执行完毕！");
  125. }
  126. }
  127. });
  128. t.start();
  129. }
  131. /**
  132. * 线程A退出等待
  133. */
  134. private void quitThreadA() {
  135. isThreadAWaiting = false;
  136. object.notify();
  137. }
  139. /**
  140. * 线程B退出等待
  141. */
  142. private void quitThreadB() {
  143. isThreadBWaiting = false;
  144. object.notify();
  145. }
  147. /**
  148. * 线程C退出等待
  149. */
  150. private void quitThreadC() {
  151. isThreadCWaiting = false;
  152. object.notify();
  153. }
  154. }

在以上代码中，我写了三个线程A，B，C用来作为等待线程，并且最后通过一个唤醒线程来唤醒这三个线程。
我的思路是这样的：
（1）通过notify()方法可以保证每次只唤醒一个线程，但是不能确保唤醒的是哪个线程。
（2）在线程A，B，C中，添加for或者while循环的方式使其进入无限等待的状态。这样能够保证notify()无论如何都不能唤醒线程。
（3）分别给A，B，C线程设置各自的标记，如果要唤醒该线程的话，就改变其状态并且跳出死循环，在最后执行下一个线程。

那么最终调用的main函数如下：
  1. public static void main(String[] args) {
  2. MyThreadFactory factory = new MyThreadFactory();
  3. factory.startThreadA();
  4. factory.startThreadB();
  5. factory.startThreadC();
  7. try {
  8. Thread.sleep( 3000);
  9. } catch (InterruptedException e) {
  10. e.printStackTrace();
  11. }
  12. factory.startWakenThread();
  13. }

最后运行的结果如下：


小结

本章是为了通过wait()，sleep()，notify()以及notifyAll()去了解它们是如何使用的，以及它们各自的意义。现在在java.util.concurrent包中，已经有很多针对多线程并发的线程池封装类和接口，大家使用起来会更加灵活和方便，并且能够实现更多并发效果。因此不太推荐大家使用wait()和notify()这种方式

猜你喜欢

转载自blog.csdn.net/rjkkaikai/article/details/81016635
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022