Java Thread等待，通知和notifyAll示例

The Object class in java contains three final methods that allows threads to communicate about the lock status of a resource. These methods are wait(), notify() and notifyAll(). So today we will look into wait, notify and notifyAll in java program.

Java中的Object类包含三个最终方法，这些方法允许线程就资源的锁定状态进行通信。 这些方法是wait（） ， notify（）和notifyAll（） 。 因此，今天我们将探讨java程序中的wait，notify和notifyAll。

用Java等待，通知和notifyAll (wait, notify and notifyAll in Java)

The current thread which invokes these methods on any object should have the object monitor else it throws java.lang.IllegalMonitorStateException exception.

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

等待 (wait)

Object wait methods has three variance, one which waits indefinitely for any other thread to call notify or notifyAll method on the object to wake up the current thread. Other two variances puts the current thread in wait for specific amount of time before they wake up.

对象等待方法具有三种变化，一种无限期等待任何其他线程调用该对象上的notify或notifyAll方法来唤醒当前线程。 其他两个差异会使当前线程在唤醒之前等待特定的时间。

通知 (notify)

notify method wakes up only one thread waiting on the object and that thread starts execution. So if there are multiple threads waiting for an object, this method will wake up only one of them. The choice of the thread to wake depends on the OS implementation of thread management.

notify方法仅唤醒一个正在等待该对象的线程，并且该线程开始执行。 因此，如果有多个线程在等待一个对象，则此方法将仅唤醒其中一个。 唤醒线程的选择取决于线程管理的OS实现。

notifyAll (notifyAll)

notifyAll method wakes up all the threads waiting on the object, although which one will process first depends on the OS implementation.

notifyAll方法唤醒等待对象的所有线程，尽管首先处理哪个线程取决于OS的实现。

These methods can be used to implement producer consumer problem where consumer threads are waiting for the objects in Queue and producer threads put object in queue and notify the waiting threads.

这些方法可用于实现生产者消费者问题 ，其中消费者线程正在等待Queue中的对象，而生产者线程则将对象放入队列中并通知正在等待的线程。

Let’s see an example where multiple threads work on the same object and we use wait, notify and notifyAll methods.

让我们看一个示例，其中多个线程在同一个对象上工作，我们使用wait，notify和notifyAll方法。

信息 (Message)

A java bean class on which threads will work and call wait and notify methods.

线程将在其上工作的Java bean类，并调用wait和notify方法。

package com.journaldev.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;
    }

}

服务员 (Waiter)

A class that will wait for other threads to invoke notify methods to complete it’s processing. Notice that Waiter thread is owning monitor on Message object using synchronized block.

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

package com.journaldev.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());
        }
    }

}

通知者 (Notifier)

A class that will process on Message object and then invoke notify method to wake up threads waiting for Message object. Notice that synchronized block is used to own the monitor of Message object.

一个将在Message对象上处理，然后调用notify方法以唤醒等待Message对象的线程的类。 注意，同步块用于拥有Message对象的监视器。

package com.journaldev.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();
        }
        
    }

}

WaitNotifyTest (WaitNotifyTest)

Test class that will create multiple threads of Waiter and Notifier and start them.

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

package com.journaldev.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");
    }

}

When we will invoke the above program, we will see below output but program will not complete because there are two threads waiting on Message object and notify() method has wake up only one of them, the other thread is still waiting to get notified.

当我们调用上面的程序时，我们将看到下面的输出，但是程序不会完成，因为有两个线程正在等待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

If we comment the notify() call and uncomment the notifyAll() call in Notifier class, below will be the output produced.

如果我们在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

Since notifyAll() method wake up both the Waiter threads and program completes and terminates after execution. That’s all for wait, notify and notifyAll in java.

由于notifyAll（）方法同时唤醒了Waiter线程，因此程序在执行后完成并终止。 这就是所有等待，java中的notify和notifyAll。

翻译自: https://www.journaldev.com/1037/java-thread-wait-notify-and-notifyall-example