Java并发编程：线程信号传递（忙等待，wait、notify、notifyall，信号丢失，虚假唤醒）

用心去追梦

于 2024-08-15 11:09:34 发布

阅读量307

点赞数 3

文章标签： java python 开发语言

本文链接：https://blog.csdn.net/qq_33240556/article/details/141217370

版权

Java并发编程中的线程信号传递是一种重要的同步机制，它用于线程之间的通信和协作。下面我将详细介绍线程信号传递的相关概念，包括忙等待、wait、notify、notifyAll方法、信号丢失以及虚假唤醒等问题。

忙等待

定义：
忙等待（Busy Waiting）是指线程在等待某个条件成立时不断地循环检查该条件，而不是让出CPU时间片。

特点：

低效：消耗大量的CPU资源。
无休眠：线程不会进入休眠状态。
不推荐使用：在多线程环境中应该避免使用忙等待。

示例：

public class BusyWaitingExample {
    private boolean condition = false;

    public static void main(String[] args) throws InterruptedException {
        BusyWaitingExample example = new BusyWaitingExample();

        Thread waiterThread = new Thread(() -> {
            while (!example.condition) {
                // 忙等待
            }
            System.out.println("Condition is now true.");
        });

        waiterThread.start();

        Thread.sleep(1000); // 等待一段时间

        example.condition = true; // 设置条件为真
        waiterThread.join(); // 等待线程结束
    }
}

wait、notify和notifyAll

定义：
wait、notify和notifyAll方法是Java中用于线程间信号传递的基本方法。这些方法只能在synchronized方法或代码块中调用，并且通常与条件变量一起使用。

特点：

wait：释放当前持有的锁，并阻塞当前线程，直到收到通知。
notify：唤醒正在等待该对象锁的一个线程。
notifyAll：唤醒所有正在等待该对象锁的线程。

示例：

public class WaitNotifyExample {
    private final Object lock = new Object();
    private boolean condition = false;

    public static void main(String[] args) throws InterruptedException {
        WaitNotifyExample example = new WaitNotifyExample();

        Thread waiterThread = new Thread(() -> {
            synchronized (example.lock) {
                while (!example.condition) {
                    try {
                        example.lock.wait(); // 等待条件变为真
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("Condition is now true.");
            }
        });

        waiterThread.start();

        Thread.sleep(1000); // 等待一段时间

        synchronized (example.lock) {
            example.condition = true; // 设置条件为真
            example.lock.notify(); // 通知等待的线程
        }

        waiterThread.join(); // 等待线程结束
    }
}

信号丢失

定义：
信号丢失是指当一个线程调用notify或notifyAll时，另一个等待中的线程未能接收到通知的情况。

特点：

非阻塞线程：如果一个线程在调用notify或notifyAll之后立即退出synchronized代码块，那么等待中的线程可能无法接收到通知。
多个等待线程：如果有多个线程在等待，notify只会唤醒其中一个线程，其他线程可能继续等待。

解决方案：

使用notifyAll以确保所有等待的线程都被唤醒。
在调用notify或notifyAll之后，保持synchronized代码块的执行，直到所有必要的操作完成。

虚假唤醒

定义：
虚假唤醒是指一个线程在没有明确调用notify或notifyAll的情况下被唤醒的情况。

特点：

随机性：虚假唤醒通常是随机发生的。
线程安全：即使发生了虚假唤醒，也应该确保程序仍然是线程安全的。

解决方案：

使用循环来检查条件是否满足，即使线程被唤醒也要检查条件是否真的满足。

示例：

public class FalseWakeupExample {
    private final Object lock = new Object();
    private boolean condition = false;

    public static void main(String[] args) throws InterruptedException {
        FalseWakeupExample example = new FalseWakeupExample();

        Thread waiterThread = new Thread(() -> {
            synchronized (example.lock) {
                while (!example.condition) {
                    try {
                        example.lock.wait(); // 等待条件变为真
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("Condition is now true.");
            }
        });

        waiterThread.start();

        Thread.sleep(1000); // 等待一段时间

        synchronized (example.lock) {
            example.condition = true; // 设置条件为真
            example.lock.notify(); // 通知等待的线程
        }

        waiterThread.join(); // 等待线程结束
    }
}