线程wait后的等待队列

常规情况

在 Java 里，无论是使用 Object 类的 wait()、notify()、notifyAll() 方法，还是使用 ReentrantLock 搭配 Condition 的 await()、signal()、signalAll() 方法，基本遵循“哪个对象调用 wait/await，线程就进入该对象对应的等待队列，且需由该对象来唤醒”的规则。

使用 Object 的 wait()、notify()、notifyAll()

每个 Java 对象都有一个与之关联的内置锁和等待队列。当线程调用某个对象的 wait() 方法时，它会释放该对象的锁，并进入这个对象的等待队列。后续要唤醒这些等待的线程，必须调用同一个对象的 notify() 或 notifyAll() 方法。

public class ObjectWaitNotifyDemo {
    private static final Object monitor = new Object();

    public static void main(String[] args) {
        Thread waitingThread = new Thread(() -> {
            synchronized (monitor) {
                try {
                    System.out.println("线程开始等待");
                    monitor.wait();
                    System.out.println("线程被唤醒，继续执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread notifyingThread = new Thread(() -> {
            synchronized (monitor) {
                try {
                    Thread.sleep(1000);
                    System.out.println("准备唤醒等待线程");
                    monitor.notify();
                    System.out.println("已唤醒等待线程");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        waitingThread.start();
        notifyingThread.start();
    }
}

在上述代码中，waitingThread 调用 monitor.wait() 进入 monitor 对象的等待队列，notifyingThread 调用 monitor.notify() 来唤醒处于该队列中的线程。

使用 ReentrantLock 和 Condition 的 await()、signal()、signalAll()

Condition 对象是与 ReentrantLock 关联的，每个 Condition 都有自己独立的等待队列。当线程调用 Condition 的 await() 方法时，它会释放 ReentrantLock 锁并进入该 Condition 的等待队列。之后要唤醒这些线程，需要调用同一个 Condition 的 signal() 或 signalAll() 方法。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionAwaitSignalDemo {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void awaitExample() {
        lock.lock();
        try {
            System.out.println("线程进入等待");
            condition.await();
            System.out.println("线程被唤醒，继续执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signalExample() {
        lock.lock();
        try {
            Thread.sleep(1000);
            System.out.println("准备唤醒等待线程");
            condition.signal();
            System.out.println("已唤醒等待线程");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ConditionAwaitSignalDemo demo = new ConditionAwaitSignalDemo();
        Thread awaitThread = new Thread(demo::awaitExample);
        Thread signalThread = new Thread(demo::signalExample);

        awaitThread.start();
        signalThread.start();
    }
}

这里，awaitExample 方法中的线程调用 condition.await() 进入 condition 的等待队列，signalExample 方法调用 condition.signal() 来唤醒该队列中的线程。

特殊情况

虽然正常情况下遵循上述规则，但也存在一些特殊情况会使线程从等待状态中恢复：

中断唤醒

如果一个线程在 wait() 或 await() 方法中等待时，另一个线程调用了该线程的 interrupt() 方法，等待的线程会抛出 InterruptedException 异常并从等待状态返回。不过这并非正常的唤醒机制，而是由于线程被中断导致的。

虚假唤醒

在某些情况下，线程可能会在没有被 notify()、notifyAll()、signal() 或 signalAll() 方法调用，也没有被中断的情况下从 wait() 或 await() 方法中返回，这种现象被称为虚假唤醒。所以在实际应用中，通常使用 while 循环来检查等待条件，以应对虚假唤醒的情况。

综上所述，在一般的同步和线程协作场景下，你的表述是成立的，但需要考虑到中断唤醒和虚假唤醒这些特殊情况。

线程通信的本质

本质上来说，wait和notify方法实现线程之间通信的核心思想是，当调用了wait方法的线程逻辑上的思想是此线程无法满足 wait方法之后的代码块的执行（例如生产/消费者模型中，消费者没有可消费的东西，生产者已经达到最大生产阈值了），故让此线程暂停执行，释放锁，加入到对象的等待队列中，并等待同一个对象进行唤醒。而notify方法的思想是此线程已经完成了可以唤醒其他线程的工作，期望其他线程可以执行。例如消费者已经消费完成，期望生成者生产，生产者已经生产完成，期望消费者消费。

Block状态和Wait状态的线程

在 Java 多线程编程中，未竞争到对象锁的线程和进入 wait 状态的线程存在明显区别，下面从状态特征、资源占用、唤醒机制、代码表现等方面进行详细阐述。

状态特征

• 未竞争到对象锁的线程：处于阻塞（BLOCKED）状态。当一个线程尝试获取一个被其他线程持有的对象锁时，如果锁不可用，该线程就会进入阻塞状态，它会在锁的入口队列中等待，直到持有锁的线程释放锁，然后再次竞争锁。
• 进入 wait 状态的线程：处于等待（WAITING）或限时等待（TIMED_WAITING）状态，具体取决于调用的是 wait() 还是 wait(long timeout) 方法。线程调用对象的 wait() 方法后，会释放持有的对象锁，并进入该对象的等待队列，等待其他线程调用该对象的 notify() 或 notifyAll() 方法来唤醒它。

资源占用

• 未竞争到对象锁的线程：线程仍然持有除该对象锁之外的其他资源，只是在等待获取特定对象的锁。它不会释放已持有的其他锁或资源，并且会持续占用 CPU 时间片来参与锁的竞争。
• 进入 wait 状态的线程：线程会释放持有的对象锁，并且不会参与 CPU 调度，因此不会占用 CPU 资源。它会暂停执行，直到被唤醒后才会重新尝试获取锁并继续执行。

唤醒机制

• 未竞争到对象锁的线程：当持有锁的线程释放锁时，处于阻塞状态的线程会参与锁的竞争。JVM 会根据一定的算法（如公平锁或非公平锁策略）从等待队列中选择一个线程获取锁，该线程就会从阻塞状态变为可运行（RUNNABLE）状态。
• 进入 wait 状态的线程：需要其他线程调用该对象的 notify() 或 notifyAll() 方法来唤醒。notify() 方法会随机唤醒等待队列中的一个线程，而 notifyAll() 方法会唤醒等待队列中的所有线程。被唤醒的线程会从等待状态变为阻塞状态，然后参与锁的竞争，获取锁后才能继续执行。

代码表现

以下是一个简单的示例代码，展示了未竞争到对象锁的线程和进入 wait 状态的线程的区别：

public class LockAndWaitExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        // 模拟未竞争到对象锁的线程
        Thread blockedThread = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Blocked thread acquired the lock.");
            }
        });

        // 模拟进入 wait 状态的线程
        Thread waitThread = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Wait thread is going to wait.");
                    lock.wait();
                    System.out.println("Wait thread is awakened.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 主线程先获取锁
        synchronized (lock) {
            // 启动阻塞线程，该线程会因为锁被占用而进入阻塞状态
            blockedThread.start();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 启动等待线程，该线程会调用 wait() 方法进入等待状态
            waitThread.start();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 唤醒等待线程
            lock.notify();
        }
    }
}

代码解释

• blockedThread：当主线程持有 lock 对象的锁时，blockedThread 尝试获取该锁，由于锁不可用，它会进入阻塞状态，直到主线程释放锁后再参与锁的竞争。
• waitThread：waitThread 进入同步块后调用 lock.wait() 方法，会释放 lock 对象的锁并进入等待状态。主线程调用 lock.notify() 方法后，waitThread 会被唤醒，然后重新竞争锁，获取锁后继续执行。

综上所述，未竞争到对象锁的线程和进入 wait 状态的线程在状态特征、资源占用、唤醒机制等方面都存在明显的区别，在多线程编程中需要根据具体需求合理使用这两种机制。

这里需要注意，wait状态的线程被唤醒后，需要先进入block状态，竞争到对象锁后才能从wait代码的位置继续执行。