无聊小知识.03 wait(),notify()虚假唤醒

1、什么是wait和notify

属于Object类的两个方法。

wait(),使当前线程等待,直到另一个线程使用notify()或notifyAll()方法唤醒。

notify(),唤醒正在wait等待的线程。

官方API文档说明:

无聊小知识.03 wait(),notify()虚假唤醒_第1张图片

2、 示例代码

既然说明了wait()和notify()的功能,那么我们手撸一段代码来试下:

/**
 * @author Shamee loop
 * @date 2023/4/9
 */
public class ObjectWaitNotifyDemo {

    public static void main(String[] args) {
        NumberOper object = new NumberOper();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                object.add();
            }
        }, "thread-add-1").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                object.sub();
            }
        }, "thread-sub-1").start();
    }
}

/**
 * 定义一个数量操作类
 * 其中包含两个方法,
 * 一个是对临界值number++;当判断number!=0,就等待number变成0后在执行。同时唤醒另一个线程
 * 另一个方法是对临界值number--;当判断number==0,就等待number!=0后在执行。同时唤醒另一个线程
 * 同时两个方法分别加了synchronized锁,确保线程安全问题
 */
class NumberOper {
    private int number = 0;

    public synchronized void add() {
        if(number != 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;
        System.out.println("线程" + Thread.currentThread().getName() + "执行了add(),number====>" + number);
        this.notifyAll();
    }

    public synchronized void sub() {
        if(number == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println("线程" + Thread.currentThread().getName() + "执行了sub(),number====>" + number);
        this.notifyAll();
    }

}

预期的结果应该是:

线程tread-add-1执行,判断到number==0,就number++;这时候控制台打印number==>1

线程tread-sub-1执行,判断到number==0,则进行等待;等到tread-add-1执行完毕后,唤醒了tread-sub-1执行,这时候tread-sub-1就执行了number--操作;这时候控制台打印number==>0

实际执行结果:

无聊小知识.03 wait(),notify()虚假唤醒_第2张图片

 果然是这样。那么这篇文章就结束了吗?

3、多个线程执行

上面操作示例,只开启了2个线程。但如果开启多个线程呢?我们再试下:

/**
 * @author Shamee loop
 * @date 2023/4/9
 */
public class ObjectWaitNotifyDemo {

    public static void main(String[] args) {
        NumberOper object = new NumberOper();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                object.add();
            }
        }, "thread-add-1").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                object.sub();
            }
        }, "thread-sub-1").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                object.add();
            }
        }, "thread-add-2").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                object.sub();
            }
        }, "thread-sub-2").start();
    }
}

/**
 * 定义一个数量操作类
 * 其中包含两个方法,
 * 一个是对临界值number++;当判断number!=0,就等待number变成0后在执行。同时唤醒另一个线程
 * 另一个方法是对临界值number--;当判断number==0,就等待number!=0后在执行。同时唤醒另一个线程
 * 同时两个方法分别加了synchronized锁,确保线程安全问题
 */
class NumberOper {
    private int number = 0;

    public synchronized void add() {
        if(number != 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;
        System.out.println("线程" + Thread.currentThread().getName() + "执行了add(),number====>" + number);
        this.notifyAll();
    }

    public synchronized void sub() {
        if(number == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println("线程" + Thread.currentThread().getName() + "执行了sub(),number====>" + number);
        this.notifyAll();
    }

}

预期的结果应该是:

线程tread-add-1执行,判断到number==0,就number++;这时候控制台打印number==>1

线程tread-sub-1执行,判断到number==0,则进行等待;等到tread-add-1执行完毕后,唤醒了tread-sub-1执行,这时候tread-sub-1就执行了number--操作;这时候控制台打印number==>0

实际执行结果:

无聊小知识.03 wait(),notify()虚假唤醒_第3张图片

 很明显结果不对了,甚至出现了负数等值。这是为啥?

4、虚假唤醒

我们来看下官方API文档怎么说:

无聊小知识.03 wait(),notify()虚假唤醒_第4张图片

而文档给出来的建议是,临界值的判断使用while。我们再试下:

public synchronized void add() {
        while(number != 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;
        System.out.println("线程" + Thread.currentThread().getName() + "执行了add(),number====>" + number);
        this.notifyAll();
    }

    public synchronized void sub() {
        while(number == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println("线程" + Thread.currentThread().getName() + "执行了sub(),number====>" + number);
        this.notifyAll();
    }

执行结果:

无聊小知识.03 wait(),notify()虚假唤醒_第5张图片

 似乎一切正常了。那么是为什么呢?用if不行用while就可以。

什么是虚假唤醒:是不想唤醒它或者说不确定是否应该唤醒,但是被唤醒了。对程序来说,wait 方法应该卡住当前程序,不应该往后执行;但是实际上并没有被卡住,而是在非预期的时间程序正常执行了,没有程序没有被卡住就是被虚假唤醒了

5、结论

在if条件判断下,他只会判断一次,如果这时候被notify唤醒之后,程序会从当前等待的代码继续执行(也就是进入了if判断之后的代码)。而如果使用while判断,唤醒后会重新执行while循环条件。如果条件成立,就继续wait。因此就出现了上面看到的现象。

好了,又白嫖了一个无聊的小知识,没用但有趣的小知识。

你可能感兴趣的:(无聊的小知识,java,java,开发语言)