文章目录
- 生产者和消费者问题
- 虚假呼唤问题解决方案
线程之间的虚假唤醒问题常出现在多线程编程中。我看国内很多教程都解释的稀里糊涂的，所以打算写一篇博客好好絮叨絮叨。
首先看一下线程虚假唤醒的定义：
多线程环境下，有多个线程执行了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条件只判断一次的尴尬情况。