Java多线程基础 线程的等待与唤醒(wait、notify、notifyAll)

Java多线程基础 线程的等待与唤醒

什么是线程的等待与唤醒

Java中通过wait(), notify()以及notifyAll()方法实现了线程的等待与唤醒功能。wait是指线程处于阻塞状态，等待其他线程的通知才能继续执行；notify和notifyAll则是唤醒等待的线程。

wait(), notify()以及notifyAll()的使用方法

这三个方法都是Object类的成员方法，最基本的用法如下：

1. wait()方法：

public final void wait() throws InterruptedException

等待其他线程的通知，将当前线程置于等待状态，直到其他线程调用该对象的notify或notifyAll方法唤醒该线程。当其他线程调用notify()或notifyAll()方法时，当前线程不一定会马上得到执行，只有获取了对象的锁后才能执行，所以使用wait()通常都放在synchronized同步代码块中。

1. notify()方法：

public final void notify()

唤醒在当前对象锁上等待的单个线程，如果有多个线程在等待，则唤醒其中一个线程，但具体唤醒哪个线程是不确定的。

1. notifyAll()方法：

public final void notifyAll()

唤醒在当前对象锁上等待的所有线程。

示例1

下面的示例演示了如何使用wait()和notify()方法实现线程的等待和唤醒。这里使用了两个线程，一个线程负责计算，另一个线程在计算完成时负责打印结果。

public class WaitAndNotifyExample {
    public static void main(String[] args) {
        final Calculator calculator = new Calculator();
        // 创建一个线程，用于计算
        Thread t1 = new Thread() {
            @Override
            public void run() {
                synchronized (calculator) {
                    calculator.calculate();
                    // 计算完成后，唤醒等待的线程
                    calculator.notify();
                }
            }
        };
        // 创建一个线程，用于打印结果
        Thread t2 = new Thread() {
            @Override
            public void run() {
                synchronized (calculator) {
                    try {
                        // 等待计算完成
                        calculator.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("result: " + calculator.getResult());
                }
            }
        };
        t1.start();
        t2.start();
    }
}

class Calculator {
    private int result;

    public void calculate() {
        for (int i = 0; i < 100000000; i++) {
            result += i;
        }
    }

    public int getResult() {
        return result;
    }
}

示例2

下面的示例演示了如何使用wait()和notifyAll()方法实现阻塞队列，当队列为空时，获取队列元素的线程会进入等待状态，当队列中有元素时，会唤醒等待的线程。

import java.util.LinkedList;

public class BlockingQueueExample {
    private LinkedList queue = new LinkedList();
    private int limit = 10;

    public synchronized void put(Object item) throws InterruptedException {
        while (queue.size() == limit) {
            // 队列已满，进入等待状态
            wait();
        }
        if (queue.isEmpty()) {
            // 队列为空，需要唤醒等待的线程
            notifyAll();
        }
        queue.addLast(item);
    }

    public synchronized Object take() throws InterruptedException {
        while (queue.isEmpty()) {
            // 队列为空，进入等待状态
            wait();
        }
        if (queue.size() == limit) {
            // 队列已满，需要唤醒添加元素的线程
            notifyAll();
        }
        return queue.removeFirst();
    }
}

以上就是关于Java多线程基础 线程的等待与唤醒的完整攻略，包含了wait()，notify()以及notifyAll()的使用方法，并且给出了两个示例供大家参考。