深入探究多线程中的虚假唤醒现象--从生产者消费者问题到高级解决方案的全方位解读

线程之间的虚假唤醒问题常出现在多线程编程中。我看国内很多教程都解释的稀里糊涂的，所以打算写一篇博客好好絮叨絮叨。

首先看一下线程虚假唤醒的定义：

多线程环境下，有多个线程执行了wait()方法，需要其他线程执行notify()或者notifyAll()方法去唤醒它们，假如多个线程都被唤醒了，但是只有其中一部分是有用的唤醒操作，其余的唤醒都是无用功；对于不应该被唤醒的线程而言，便是虚假唤醒。
比如：仓库有货了才能出库，突然仓库入库了一个货品；这时所有的线程（货车）都被唤醒，来执行出库操作；实际上只有一个线程（货车）能执行出库操作，其他线程都是虚假唤醒。

接下来我们用一个例子去详细上面这个解释，因为你看这个解释可能已经看蒙了。

生产者和消费者问题

• 我们定义A、C线程为生产者，负责num+1

          //A:num+1
          new Thread(()->{
              for (int i=0;i<10;i++){
                  try {
                      data.increment();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          },"A").start();
  
          //C:num+1
          new Thread(()->{
              for (int i=0;i<10;i++){
                  try {
                      data.increment();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          },"C").start();
  

• 我们定义B、D线程为消费者，负责num-1

          //B:num-1
          new Thread(()->{
              for (int i=0;i<10;i++){
                  try {
                      data.decrement();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          },"B").start();
  
   		new Thread(()->{
              for (int i=0;i<10;i++){
                  try {
                      data.decrement();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          },"D").start();
  

• 我们定义num为临界区共享资源，由生产者和消费者读写

    private int number=0;
  

我们完整写下来就是：

package org.example;

/**
 * @author linghu
 * @date 2023/12/16 16:45
 * A num+1
 * B num-1
 * 顺序：判断->业务->通知
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

        //A:num+1
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        //B:num-1
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

class Data{
    private int number=0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if (number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notify();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if(number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notify();
    }


}

在上面代码中， increment和 decrement分别做加法和减法操作。这两个操作由四个线程ABCD去执行，A、C线程执行加法，B、D线程执行减法。

我们执行上面的代码会发生如下：

上图发现，C、D线程执行下来已经出现了-1、、、。这就是我们说的线程虚假唤醒问题。

线程虚假唤醒问题即：

A先执行，执行时调用了wait方法，那它会等待，此时会释放锁，那么线程B获得锁并且也会执行wait方法，两个加线程一起等待被唤醒。此时减线程中的某一个线程执行完毕并且唤醒了这俩加线程，那么这俩加线程不会一起执行，其中A获取了锁并且加1，执行完毕之后B再执行。如果是if的话，那么A修改完num后，B不会再去判断num的值，直接会给num+1。如果是while的话，A执行完之后，B还会去判断num的值，因此就不会执行。

这里的重点是： wait()以后会线程会释放锁！由于我们上面用的 if条件判断 number的值，所以A线程被唤醒执行完毕以后，轮到C线程开始执行的时候，C线程就会跳过下面这个判断：

		if(number==0){
            //等待
            this.wait();
        }

直接执行如下代码：

 //-1
    public synchronized void decrement() throws InterruptedException {
        if(number==0){
            //等待
            this.wait();
        }
        //上面的判断直接跳过
        //直接执行如下代码....
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notify();
    }

是的，问题就在于这个 if判断，导致了线程虚假唤醒。

我们在明确一下上面的结论：

AC线程负责去做加法，首先会判断num的值，如果num不为0，那么两个线程就开始等待，释放锁，这个时候CD线程获得锁去做减法，也会判断num的值，num的值如果不为0.然后开始做减法，做完减法就开始呼唤AC线程。AC线程被呼唤以后，A线程执行完毕，这个时候由于C线程中用了if判断，那么C线程执行的时候，就不会执行if判断了，于是导致了上面的线程虚假唤醒问题。

虚假呼唤问题解决方案

其实就是把上面线程执行的加法减法方法中的条件if改成while即可：

package org.example;

/**
 * @author linghu
 * @date 2023/12/16 16:45
 * A num+1
 * B num-1
 * 顺序：判断->业务->通知
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();
        //A:num+1
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        //B:num-1
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

class Data{
    private int number=0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notifyAll();
    }


}

改成 while循环以后，A执行线程完毕以后释放锁，C线程才会继续执行while里的判断，这样就避免了if条件只判断一次的尴尬情况。