虚假唤醒问题

约定不等于承诺〃 2022-09-11 01:18 225阅读 0赞

一般而言线程调用wait()方法后，需要其他线程调用notify,notifyAll方法后，线程才会从wait方法中返回，

而虚假唤醒(spurious wakeup)是指线程通过判断（如果是if判断），符合条件就进入阻塞，当该线程被其他线程唤醒（在哪里阻塞就在哪里唤醒），就不会判断是否满足if条件，直接程序往下 执行。因为如果不符合if条件判断是不应该执行的，但是该线程却真实的执行了。所以使用if条件判断进入wait阻塞被唤醒后可能出现虚假唤醒问题

synchronized (obj) {
                   if (<condition does not hold>)
                       obj.wait();
                   ... // Perform action appropriate to condition
               }

虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待。 换句话说，等待应该总是出现在循环中，就像这样：

As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:
               synchronized (obj) { 
                   while (<condition does not hold>)
                       obj.wait();
                   ... // Perform action appropriate to condition
               }

（有关此主题的更多信息，请参阅Doug Lea的“Java并行编程（第二版）”（Addison-Wesley，2000）中的第3.2.3节或Joshua Bloch的“有效Java编程语言指南”（Addison- Wesley，2001）。

## 案例 ##

*  假设这个共享变量的初始值为0，
 *  场景—四个线程，如果变量为0，t1、t3可以对变量执行+1操作并唤醒其他线程,如果变量为1进入阻塞
 *  如果变量为1，t2、t4可以对变量执行-1操作并唤醒其他线程，如果变量为0进入阻塞
 *  每个线程执行10次

package com.dongguo.concurrent.waitnotify;
    
    /** * @author Dongguo * @date 2021/9/3 0003-13:15 * @description: 生产者消费者 * 四个线程t1加1，t2减1，t3加1，t4减1 * 虚假唤醒问题 */
    public class ThreadWaitNotifyDemo { 
        public static void main(String[] args) { 
            Number number = new Number();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        //为了体现出虚假唤醒问题
                        Thread.sleep(200);
                        number.incry();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }, "t1").start();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        Thread.sleep(300);
                        number.decry();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }, "t2").start();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        Thread.sleep(400);
                        number.incry();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }, "t3").start();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        Thread.sleep(500);
                        number.decry();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }, "t4").start();
        }
    }
    
    class Number { 
        private int count;
    
        public synchronized void incry() throws InterruptedException { 
            if (count != 0) { 
                this.wait();
            }
            count++;
            System.out.println(Thread.currentThread().getName() + "加一成功，count值为：" + count);
            this.notifyAll();
        }
    
        public synchronized void decry() throws InterruptedException { 
            if (count == 0) { 
                this.wait();
            }
            count--;
            System.out.println(Thread.currentThread().getName() + "减一成功，count值为：" + count);
            this.notifyAll();
        }
    }

![image-20210903135617675][]

多线程交互中，必须要防止多线程的虚假唤醒，等待应该总是出现在循环中，即只能用while不能用if

### **原因分析：** ###

目前有四个线程 t1执行+1、t2执行-1、t3执行+1、t4执行-1

线程的创建是由操作系统决定的，所以有可能t1先创建执行，也有可能t2先创建执行

假设t1线程先创建执行+1操作，然后通知唤醒其他线程 值为1

假设此时t3线程抢到运行机会执行+1操作， 此时判断count的值为1，那么就执行wait方法进入阻塞状态 值为1

假设此时t1线程抢到运行机会执行+1操作， 此时判断count的值为1，那么就执行wait方法进入阻塞状态 值为1

假设此时t2线程抢到了运行机会执行-1操作，执行-1操作后通知唤醒其他线程 值为0

假设此时t3线程被唤醒又抢到了运行机会执行+1操作，wait方法的机制是在哪里阻塞，就会在哪里被唤醒，if判断就没有生效了 ，执行+1操作后通知唤醒其他线程 值为1

public synchronized void incry() throws InterruptedException { 
            if (count != 0) { 
                this.wait();//在哪里阻塞，就在哪里被唤醒，往下执行
            }
            count++;//被唤醒接着执行+1
            System.out.println(Thread.currentThread().getName() + "加一成功，count值为：" + count);
            this.notifyAll();
        }

假设此时t1线程被唤醒又抢到了运行机会执行+1操作，wait方法的机制是在哪里阻塞，就会在哪里被唤醒，if判断就没有生效了 ，执行+1操作后通知唤醒其他线程 值为2.

### **解决方案：** ###

if变为while

package com.dongguo.concurrent.waitnotify;
    
    /** * @author Dongguo * @date 2021/9/3 0003-13:15 * @description: 生产者消费者 * 四个线程t1加1，t2减1，t3加1，t4减1 * 虚假唤醒问题 */
    public class ThreadWaitNotifyDemo { 
        public static void main(String[] args) { 
            Number number = new Number();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        //为了体现出虚假唤醒问题
                        Thread.sleep(200);
                        number.incry();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }, "t1").start();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        Thread.sleep(300);
                        number.decry();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }, "t2").start();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        Thread.sleep(400);
                        number.incry();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }, "t3").start();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        Thread.sleep(500);
                        number.decry();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }, "t4").start();
        }
    }
    
    class Number { 
        private int count;
    
        public synchronized void incry() throws InterruptedException { 
            while (count != 0) { 
                this.wait();
            }
            count++;
            System.out.println(Thread.currentThread().getName() + "加一成功，count值为：" + count);
            this.notifyAll();
        }
    
        public synchronized void decry() throws InterruptedException { 
            while (count == 0) { 
                this.wait();
            }
            count--;
            System.out.println(Thread.currentThread().getName() + "减一成功，count值为：" + count);
            this.notifyAll();
        }
    }

运行结果

t1加一成功，count值为：1
    t2减一成功，count值为：0
    t3加一成功，count值为：1
    t4减一成功，count值为：0
    t1加一成功，count值为：1
    t2减一成功，count值为：0
    t1加一成功，count值为：1
    t2减一成功，count值为：0
    t3加一成功，count值为：1
    t4减一成功，count值为：0
    t1加一成功，count值为：1
    t2减一成功，count值为：0
    t1加一成功，count值为：1
    t4减一成功，count值为：0
    t1加一成功，count值为：1
    t2减一成功，count值为：0
    t3加一成功，count值为：1
    t2减一成功，count值为：0
    t1加一成功，count值为：1
    t4减一成功，count值为：0
    t3加一成功，count值为：1
    t2减一成功，count值为：0
    t1加一成功，count值为：1
    t2减一成功，count值为：0
    t3加一成功，count值为：1
    t4减一成功，count值为：0
    t1加一成功，count值为：1
    t2减一成功，count值为：0
    t1加一成功，count值为：1
    t4减一成功，count值为：0
    t3加一成功，count值为：1
    t2减一成功，count值为：0
    t3加一成功，count值为：1
    t4减一成功，count值为：0
    t3加一成功，count值为：1
    t4减一成功，count值为：0
    t3加一成功，count值为：1
    t4减一成功，count值为：0
    t3加一成功，count值为：1
    t4减一成功，count值为：0

[image-20210903135617675]: /images/20220829/bf067c560d6e437c95353145c23d4d09.png