Java 线程的等待、通知和通知所有示例

Java中的Object类包含了三个最终方法，用于线程之间关于资源锁状态的通信。这些方法是wait()、notify()和notifyAll()。所以今天我们将深入研究Java程序中的wait、notify和notifyAll。

在Java中，等待、通知和广播所有的方法是指”wait”、”notify”和”notifyAll”。

调用这些方法的当前线程在任何对象上都应该拥有对象监视器，否则将抛出 java.lang.IllegalMonitorStateException 异常。

等一下

对象的等待方法有三种变体，其中一种无限期地等待任何其他线程在对象上调用notify或notifyAll方法来唤醒当前线程。另外两种变体在特定时间之前将当前线程置于等待状态，然后再唤醒。

通知

通知方法只唤醒一个正在等待该对象的线程，并且该线程开始执行。因此，如果有多个线程等待一个对象，这个方法只会唤醒其中一个。唤醒哪个线程的选择取决于操作系统对线程管理的实现。

通知所有人

notifyAll方法会唤醒所有正在等待该对象的线程，然而，哪个线程先执行取决于操作系统的实现。这些方法可以用于实现”生产者-消费者”问题，其中消费者线程在队列中等待对象，而生产者线程将对象放入队列并通知等待的线程。让我们看一个示例，其中多个线程在同一个对象上工作，我们使用wait、notify和notifyAll方法。

信息

一个会被线程调用并使用wait和notify方法的Java Bean类。

package com.Olivia.concurrency;

public class Message {
    private String msg;
    
    public Message(String str){
        this.msg=str;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String str) {
        this.msg=str;
    }

}

服务员请

一个等待其他线程调用notify方法以完成其处理的类。请注意，Waiter线程在使用synchronized块拥有Message对象的监视器。

package com.Olivia.concurrency;

public class Waiter implements Runnable{
    
    private Message msg;
    
    public Waiter(Message m){
        this.msg=m;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        synchronized (msg) {
            try{
                System.out.println(name+" waiting to get notified at time:"+System.currentTimeMillis());
                msg.wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(name+" waiter thread got notified at time:"+System.currentTimeMillis());
            //process the message now
            System.out.println(name+" processed: "+msg.getMsg());
        }
    }

}

通知者

一个处理Message对象并调用notify方法唤醒等待Message对象的线程的类。请注意，使用synchronized块来拥有Message对象的监视器。

package com.Olivia.concurrency;

public class Notifier implements Runnable {

    private Message msg;
    
    public Notifier(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name+" started");
        try {
            Thread.sleep(1000);
            synchronized (msg) {
                msg.setMsg(name+" Notifier work done");
                msg.notify();
                // msg.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }

}

等待通知测试

测试类将创建多个Waiter和Notifier线程并启动它们。

package com.Olivia.concurrency;

public class WaitNotifyTest {

    public static void main(String[] args) {
        Message msg = new Message("process it");
        Waiter waiter = new Waiter(msg);
        new Thread(waiter,"waiter").start();
        
        Waiter waiter1 = new Waiter(msg);
        new Thread(waiter1, "waiter1").start();
        
        Notifier notifier = new Notifier(msg);
        new Thread(notifier, "notifier").start();
        System.out.println("All the threads are started");
    }

}

当我们调用上述程序时，我们将看到下方的输出，但程序不会完成，因为有两个线程正在等待Message对象，而notify()方法只唤醒其中一个线程，另一个线程仍然在等待通知。

waiter waiting to get notified at time:1356318734009
waiter1 waiting to get notified at time:1356318734010
All the threads are started
notifier started
waiter waiter thread got notified at time:1356318735011
waiter processed: notifier Notifier work done

如果我们在Notifier类中将notify()调用注释掉，并取消注释notifyAll()的调用，下面将会产生以下输出。

waiter waiting to get notified at time:1356318917118
waiter1 waiting to get notified at time:1356318917118
All the threads are started
notifier started
waiter1 waiter thread got notified at time:1356318918120
waiter1 processed: notifier Notifier work done
waiter waiter thread got notified at time:1356318918120
waiter processed: notifier Notifier work done

在Java中，notifyAll()方法会唤醒所有的等待线程，并在执行结束后完成和终止程序。这就是wait、notify和notifyAll的全部内容。