什么是虚假唤醒？为什么会产生虚假唤醒？

什么是虚假唤醒？

当一定的条件触发时会唤醒很多在阻塞态的线程，但只有部分的线程唤醒是有用的，其余线程的唤醒是多余的。
比如说卖货，如果本来没有货物，突然进了一件货物，这时所有的顾客都被通知了，但是只能一个人买，所以其他人都是无用的通知。

虚假唤醒演示

package com.jeesite.modules.asysutils.test.juc;

/**
 * 线程之间的通信问题：也就是生产者和消费者的问题，通知和唤醒
 * 线程交替执行，A线程走完，通知B线程去执行。
 */
public class A {
    public static void main(String[] args) {
        Date date = new Date();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "生产者A").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "生产者B").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "消费者C").start();

        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "消费者D").start();
    }
}

//判断业务，等待，通知
class Date {//资源类
    private int num = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "进入");
        if (num > 0) {
            this.wait();
            //当num不等于0时，需要等待
        }
        num++;
        //当++完毕后，需要通知其他线程
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + "计数器：" + num);
    }

    public synchronized void decrement() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "进入");
        if (num == 0) {
            this.wait();
            //当num等于0时，需要等待
        }
        num--;
        //当--完毕后，通知其他线程
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + "计数器：" + num);
    }
}

执行结果

生产者A进入
生产者A计数器：1
生产者A进入
生产者B进入
消费者C进入
消费者C计数器：0
消费者C进入
生产者B计数器：1
生产者B进入
生产者A计数器：2
生产者A进入
生产者B计数器：3
生产者B进入
消费者C计数器：2
消费者C进入
消费者C计数器：1
消费者C进入
消费者C计数器：0
消费者C进入
生产者B计数器：1
生产者B进入
消费者D进入
消费者D计数器：0
消费者D进入
生产者A计数器：1
生产者A进入
消费者D计数器：0
消费者D进入
生产者B计数器：1
生产者B进入
消费者C计数器：0
生产者B计数器：1
消费者D计数器：0
消费者D进入
生产者A计数器：1
生产者A进入
消费者D计数器：0
消费者D进入
生产者A计数器：1
消费者D计数器：0

步骤分析

1、生产者A进入，计数器为0，走过if判断，加1，现值1，生产者A再次进入，交出线程，但是注意一点是已经走过if判断了，下次再执行是直接执行后面的语句

生产者A进入
生产者A计数器：1
生产者A进入

2、生产者B进入，交出线程，消费者C进入，计数器减1

生产者B进入
消费者C进入
消费者C计数器：0

3、消费者C进入，计数器为0，唤醒生产者B线程，加1，现值1

消费者C进入
生产者B计数器：1
生产者B进入

4、重点，由于在第一步时A已经走过了if判断，再次执行后面的语句，现在变为了2，生产者A进入，A交出线程，生产者B在上一步已经进入，再次执行后面的语句，现在变为了3

生产者A计数器：2
生产者A进入
生产者B计数器：3

为什么会产生虚假唤醒？

从上面的例子可以看出，同步失败的主要原因有以下几个点：

生产者唤醒了所有处于阻塞队列中的线程，我们希望的是生产者A唤醒的应该是两个消费者，而不是唤醒了生产者B
我们都知道，wait方法的作用是将线程停止执行并送入到阻塞队列中，但是wait方法还有一个操作就是释放锁。因此当生产者A执行wait方法时，该线程就会把它持有的对象锁释放，这样生产者B就可以拿到锁进入synchronized修饰的方法中，即使它被卡在if判断，但被唤醒后它就会又添加一个产品了。

如何解决虚假唤醒？

从上面分析可以知道导致虚假唤醒的原因主要就是一个线程直接在if代码块中被唤醒了，这时它已经跳过了if判断。我们只需要将if判断改为while，这样线程就会被重复判断而不再会跳出判断代码块，从而不会产生虚假唤醒这种情况了。

package com.jeesite.modules.asysutils.test.juc;

/**
 * 线程之间的通信问题：也就是生产者和消费者的问题，通知和唤醒
 * 线程交替执行，A线程走完，通知B线程去执行。
 */
public class A {
    public static void main(String[] args) {
        Date date = new Date();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "生产者A").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "生产者B").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "消费者C").start();

        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "消费者D").start();
    }
}

//判断业务，等待，通知
class Date {//资源类
    private int num = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "进入");
        while (num > 0) {
            this.wait();
            //当num不等于0时，需要等待
        }
        num++;
        //当++完毕后，需要通知其他线程
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + "计数器：" + num);
    }

    public synchronized void decrement() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "进入");
        while (num == 0) {
            this.wait();
            //当num等于0时，需要等待
        }
        num--;
        //当--完毕后，通知其他线程
        this.notifyAll();
        System.out.println(Thread.currentThread().getName() + "计数器：" + num);
    }
}

执行结果

生产者A进入
生产者A计数器：1
生产者A进入
生产者B进入
消费者C进入
消费者C计数器：0
消费者C进入
生产者B计数器：1
生产者B进入
消费者C计数器：0
消费者C进入
生产者A计数器：1
生产者A进入
消费者D进入
消费者D计数器：0
消费者D进入
生产者B计数器：1
生产者B进入
消费者C计数器：0
消费者C进入
生产者A计数器：1
生产者A进入
消费者D计数器：0
消费者D进入
生产者B计数器：1
生产者B进入
消费者C计数器：0
消费者C进入
生产者A计数器：1
生产者A进入
消费者D计数器：0
消费者D进入
生产者B计数器：1
生产者B进入
消费者C计数器：0
生产者A计数器：1
消费者D计数器：0
消费者D进入
生产者B计数器：1
消费者D计数器：0

可以看出，无论CPU时间片给到哪个线程都不会再发生虚假唤醒了