转：【Java并发编程】之十一：线程间通信中notify通知的遗漏（含代码）

2022-10-06 12:49:22

转载请注明出处：http://blog.csdn.net/ns_code/article/details/17228213

notify通知的遗漏很容易理解，即threadA还没开始wait的时候，threadB已经notify了，这样，threadB通知是没有任何响应的，当threadB退出synchronized代码块后，threadA再开始wait，便会一直阻塞等待，直到被别的线程打断。

遗漏通知的代码

下面给出一段代码演示通知是如何遗漏的，如下：

  1. public class MissedNotify extends Object {
  2. private Object proceedLock;
  3. public MissedNotify() {
  4. print("in MissedNotify()");
  5. proceedLock = new Object();
  6. }
  7. public void waitToProceed() throws InterruptedException {
  8. print("in waitToProceed() - entered");
  9. synchronized ( proceedLock ) {
  10. print("in waitToProceed() - about to wait()");
  11. proceedLock.wait();
  12. print("in waitToProceed() - back from wait()");
  13. }
  14. print("in waitToProceed() - leaving");
  15. }
  16. public void proceed() {
  17. print("in proceed() - entered");
  18. synchronized ( proceedLock ) {
  19. print("in proceed() - about to notifyAll()");
  20. proceedLock.notifyAll();
  21. print("in proceed() - back from notifyAll()");
  22. }
  23. print("in proceed() - leaving");
  24. }
  25. private static void print(String msg) {
  26. String name = Thread.currentThread().getName();
  27. System.out.println(name + ": " + msg);
  28. }
  29. public static void main(String[] args) {
  30. final MissedNotify mn = new MissedNotify();
  31. Runnable runA = new Runnable() {
  32. public void run() {
  33. try {
  34. //休眠1000ms，大于runB中的500ms，
  35. //是为了后调用waitToProceed，从而先notifyAll，后wait，
  36. //从而造成通知的遗漏
  37. Thread.sleep(1000);
  38. mn.waitToProceed();
  39. } catch ( InterruptedException x ) {
  40. x.printStackTrace();
  41. }
  42. }
  43. };
  44. Thread threadA = new Thread(runA, "threadA");
  45. threadA.start();
  46. Runnable runB = new Runnable() {
  47. public void run() {
  48. try {
  49. //休眠500ms，小于runA中的1000ms，
  50. //是为了先调用proceed，从而先notifyAll，后wait，
  51. //从而造成通知的遗漏
  52. Thread.sleep(500);
  53. mn.proceed();
  54. } catch ( InterruptedException x ) {
  55. x.printStackTrace();
  56. }
  57. }
  58. };
  59. Thread threadB = new Thread(runB, "threadB");
  60. threadB.start();
  61. try {
  62. Thread.sleep(10000);
  63. } catch ( InterruptedException x ) {}
  64. //试图打断wait阻塞
  65. print("about to invoke interrupt() on threadA");
  66. threadA.interrupt();
  67. }
  68. }

执行结果如下：

转：【Java并发编程】之十一：线程间通信中notify通知的遗漏（含代码）

分析：由于threadB在执行mn.proceed（）之前只休眠了500ms，而threadA在执行mn.waitToProceed（）之前休眠了1000ms，因此，threadB会先苏醒，继而执行mn.proceed（），获取到proceedLock的对象锁，继而执行其中的notifyAll（），当退出proceed（）方法中的synchronized代码块时，threadA才有机会获取proceedLock的对象锁，继而执行其中的wait（）方法，但此时notifyAll（）方法已经执行完毕，threadA便漏掉了threadB的通知，便会阻塞下去。后面主线程休眠10秒后，尝试中断threadA线程，使其抛出InterruptedException。

修正后的代码

为了修正MissedNotify，需要添加一个boolean指示变量，该变量只能在同步代码块内部访问和修改。修改后的代码如下：

  1. public class MissedNotifyFix extends Object {
  2. private Object proceedLock;
  3. //该标志位用来指示线程是否需要等待
  4. private boolean okToProceed;
  5. public MissedNotifyFix() {
  6. print("in MissedNotify()");
  7. proceedLock = new Object();
  8. //先设置为false
  9. okToProceed = false;
  10. }
  11. public void waitToProceed() throws InterruptedException {
  12. print("in waitToProceed() - entered");
  13. synchronized ( proceedLock ) {
  14. print("in waitToProceed() - entered sync block");
  15. //while循环判断，这里不用if的原因是为了防止早期通知
  16. while ( okToProceed == false ) {
  17. print("in waitToProceed() - about to wait()");
  18. proceedLock.wait();
  19. print("in waitToProceed() - back from wait()");
  20. }
  21. print("in waitToProceed() - leaving sync block");
  22. }
  23. print("in waitToProceed() - leaving");
  24. }
  25. public void proceed() {
  26. print("in proceed() - entered");
  27. synchronized ( proceedLock ) {
  28. print("in proceed() - entered sync block");
  29. //通知之前，将其设置为true，这样即使出现通知遗漏的情况，也不会使线程在wait出阻塞
  30. okToProceed = true;
  31. print("in proceed() - changed okToProceed to true");
  32. proceedLock.notifyAll();
  33. print("in proceed() - just did notifyAll()");
  34. print("in proceed() - leaving sync block");
  35. }
  36. print("in proceed() - leaving");
  37. }
  38. private static void print(String msg) {
  39. String name = Thread.currentThread().getName();
  40. System.out.println(name + ": " + msg);
  41. }
  42. public static void main(String[] args) {
  43. final MissedNotifyFix mnf = new MissedNotifyFix();
  44. Runnable runA = new Runnable() {
  45. public void run() {
  46. try {
  47. //休眠1000ms，大于runB中的500ms，
  48. //是为了后调用waitToProceed，从而先notifyAll，后wait，
  49. Thread.sleep(1000);
  50. mnf.waitToProceed();
  51. } catch ( InterruptedException x ) {
  52. x.printStackTrace();
  53. }
  54. }
  55. };
  56. Thread threadA = new Thread(runA, "threadA");
  57. threadA.start();
  58. Runnable runB = new Runnable() {
  59. public void run() {
  60. try {
  61. //休眠500ms，小于runA中的1000ms，
  62. //是为了先调用proceed，从而先notifyAll，后wait，
  63. Thread.sleep(500);
  64. mnf.proceed();
  65. } catch ( InterruptedException x ) {
  66. x.printStackTrace();
  67. }
  68. }
  69. };
  70. Thread threadB = new Thread(runB, "threadB");
  71. threadB.start();
  72. try {
  73. Thread.sleep(10000);
  74. } catch ( InterruptedException x ) {}
  75. print("about to invoke interrupt() on threadA");
  76. threadA.interrupt();
  77. }
  78. }

执行结果如下：

转：【Java并发编程】之十一：线程间通信中notify通知的遗漏（含代码）

注意代码中加了注释的部分，在threadB进行通知之前，先将okToProceed置为true，这样如果threadA将通知遗漏，那么就不会进入while循环，也便不会执行wait方法，线程也就不会阻塞。如果通知没有被遗漏，wait方法返回后，okToProceed已经被置为true，下次while循环判断条件不成立，便会退出循环。

这样，通过标志位和wait、notifyAll的配合使用，便避免了通知遗漏而造成的阻塞问题。

 总结：在使用线程的等待/通知机制时，一般都要配合一个boolean变量值（或者其他能够判断真假的条件），在notify之前改变该boolean变量的值，让wait返回后能够退出while循环（一般都要在wait方法外围加一层while循环，以防止早期通知），或在通知被遗漏后，不会被阻塞在wait方法处。这样便保证了程序的正确性。

上一篇：工具 | 终于等到你！地表最强工具来袭！


下一篇：Android数据的四种存储方式SharedPreferences、SQLite、Content Provider和File （三） —— SharePreferences