Java多线程是个很复杂的问题，尤其在多线程在任何给定的时间访问共享资源需要更加注意。Java 5引入了一些类比如BlockingQueue 和Executors 类提供了易于使用的API，避免了一些复杂性。使用这些类比直接使用wait()和notify()同步处理的让程序员感到更加自信。我也推荐使用这些新的API来同步，但是很多时候我们出于各种原因需要旧方式，例如维护遗留代码。在这些情况下，熟悉这些方法将有助于你理解。在本教程中，我讨论关于wait()，notify()和notifyall()的一些概念。

什么是wait()，notify()和notifyall()方法？

在进入概念之前，让我们记下这些方法的基本定义。
在Java中Object类有三个final方法允许线程了解资源的锁定状态，它们是：

1. wait()：

在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。
当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。
它告诉调用线程放弃锁。我们不可能用纯Java实现wait()法：它是一个native method。
它被用来使线程等待某个条件，它必须在同步区域内部被调用，这个同步区域将对象锁定在了调用wait方法的对象上。始终应该使用wait循环模式来调用wait方法，永远不要在循环之外调用wait方法。循环会在等待之前和之后测试条件。
在等待之前测试条件，当条件已经成立时立即就跳过等待，这对确保活性时必要的。
在等待之后测试条件，如果条件不成立的话继续等待，这对于确保安全性时必要的。
一般使用wait()方法的语法是如下：

synchronized( lockObject )
{ 
    while( ! condition )
    { 
        lockObject.wait();
    }
     
    //take the action here;
}

2.notify()：

唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。
唤醒在同一对象上调用wait()处于等待的线程。应该指出的是，调用notify()实际上并没有放弃对资源上的锁。它告诉等待线程可以唤醒。然而，如果对某一资源调用notify()，但同步块内的资源的执行还需要进行10秒，那么线程需要等待额外的10秒，对象上的锁被释放，被唤醒的线程才能执行。

一般调用notify()方法的语法如下：

synchronized(lockObject) 
{
    //establish_the_condition;
 
    lockObject.notify();
     
    //any additional code if needed
}

3.notifyall()：

它唤醒所有在同一对象上调用wait()的线程。在大多数情况下，优先级最高的线程将首先运行，但没有保证。其他的都和notify()方法一样。
一般调用notifyall()方法的语法如下：

synchronized(lockObject) 
{
    establish_the_condition;
 
    lockObject.notifyAll();
}

在一般情况下，总应该调用notifyAll将唤醒所有需要被唤醒的线程。你可能也会唤醒其他一些线程，但这不影响程序的正确性，这些线程醒来之后，会检查他们正在等待的条件，如果发现条件不满足，就会继续等待
到目前为止，我们学到了一些你可能已经知道的基本知识。让我们编写一个小程序来理解如何使用这些方法获得预期的结果。

如何使用wait()，notify()和notifyall()方法

在这个练习中，我们将使用wait()和notify()方法解决生产者消费者问题。让程序简单，关注于wait()和notify()方法的使用，我们将只涉及一个生产者和消费者线程。
该程序的其他特点是：
1)生产者线程每秒生产新资源，并放在taskQueue中。
2)消费者线程需要1秒的过程从taskQueue中消耗资源。
3)对taskqueue最大容量是5，即在任何给定的时间最大可以存在5个资源在taskQueue中，。
4)两个线程无限运行。

设计生产者线程

下面是基于我们需求的生产者线程代码：

class Producer implements Runnable
{
   private final List<Integer> taskQueue;
   private final int           MAX_CAPACITY;
 
   public Producer(List<Integer> sharedQueue, int size)
   {
      this.taskQueue = sharedQueue;
      this.MAX_CAPACITY = size;
   }
 
   @Override
   public void run()
   {
      int counter = 0;
      while (true)
      {
         try
         {
            produce(counter++);
         } 
         catch (InterruptedException ex)
         {
            ex.printStackTrace();
         }
      }
   }
 
   private void produce(int i) throws InterruptedException
   {
      synchronized (taskQueue)
      {
         while (taskQueue.size() == MAX_CAPACITY)
         {
            System.out.println("Queue is full " + Thread.currentThread().getName() + " is waiting , size: " + taskQueue.size());
            taskQueue.wait();
         }
           
         Thread.sleep(1000);
         taskQueue.add(i);
         System.out.println("Produced: " + i);
         taskQueue.notifyAll();
      }
   }
}

1)在这里，produce(counter++)代码被写入无限循环中，这样生产者就可以定期生成元素。
2)我们已经在produce()方法中第一节提到的一般准则添加了wait()方法。
3)一旦等待结束，生产者将一个元素加入taskQueue，然后调用 notifyall()方法唤醒其他线程。因为上次wait()方法被消费者线程调用（这就是为什么生产者从等待状态），消费者被唤醒。
4)如果准备好消费元素，消费线程被唤醒。
5)注意两个线程都使用了sleep()方法来模拟创造和消费要素的时间延迟。

设计消费者线程

下面是基于我们需求的消费者线程代码：

class Consumer implements Runnable
{
   private final List<Integer> taskQueue;
 
   public Consumer(List<Integer> sharedQueue)
   {
      this.taskQueue = sharedQueue;
   }
 
   @Override
   public void run()
   {
      while (true)
      {
         try
         {
            consume();
         } catch (InterruptedException ex)
         {
            ex.printStackTrace();
         }
      }
   }
 
   private void consume() throws InterruptedException
   {
      synchronized (taskQueue)
      {
         while (taskQueue.isEmpty())
         {
            System.out.println("Queue is empty " + Thread.currentThread().getName() + " is waiting , size: " + taskQueue.size());
            taskQueue.wait();
         }
         Thread.sleep(1000);
         int i = (Integer) taskQueue.remove(0);
         System.out.println("Consumed: " + i);
         taskQueue.notifyAll();
      }
   }
}

1)这里的consume()代码被写在无限循环，让消费者保持无论何时消费taskqueue中的元素..
2)一旦等待结束，消费者从taskQueue中移除一个元素，然后调用notifyall()方法唤醒其他线程。因为上次wait()方法被生产者线程调用（这就是为什么生产者在等待状态），生产者线程收到通知被唤醒。
3)如果准备好生产元素，生产者线程获得通知。

测试应用

现在测试生产者和消费者线程。

public class ProducerConsumerExampleWithWaitAndNotify
{
   public static void main(String[] args)
   {
      List<Integer> taskQueue = new ArrayList<Integer>();
      int MAX_CAPACITY = 5;
      Thread tProducer = new Thread(new Producer(taskQueue, MAX_CAPACITY), "Producer");
      Thread tConsumer = new Thread(new Consumer(taskQueue), "Consumer");
      tProducer.start();
      tConsumer.start();
   }
}

Output:

Produced: 0

Consumed: 0

Queue is empty Consumer is waiting , size: 0

Produced: 1

Produced: 2

Consumed: 1

Consumed: 2

Queue is empty Consumer is waiting , size: 0

Produced: 3

Produced: 4

Consumed: 3

Produced: 5

Consumed: 4

Produced: 6

Consumed: 5

Consumed: 6

Queue is empty Consumer is waiting , size: 0

Produced: 7

Consumed: 7

Queue is empty Consumer is waiting , size: 0

我建议您将生产者和消费者线程所花费的时间改为不同的时间，并在不同的场景中检查不同的输出。

wait()，notify()和notifyall()方法在面试中的问题

当notify()被调用，但没有线程等待会发生什么？

在一般情况下，如果这些方法被正确使用，大多数情况下都不会出现这种情况。但如果notify()方法被调用时，没有其它线程等待，notify()只是返回，并丢失通知。

由于等待和通知机制不知道它发送通知的条件，所以假设没有线程等待，通知将被忽略。一个后来执行的wait()方法的线程必须等待下一个通知发生。

wait()方法释放或获取锁的时候是否存在一个竞争条件？

wait()方法与锁机制紧密结合。在等待线程处于接收通知的状态之前，对象锁实际上不会释放。这意味着只有当线程状态发生变化时，它才能够接收通知，锁才被保存。该系统这个机制防止任何竞争条件发生。

类似地，系统确保在将线程移动到等待状态之前完全锁定对象。

如果一个线程接受到通知，那么是否就保证了条件是被正确设置的？

简单地说，不保证，调用wait()方法之前，一个线程在拥有同步锁的情况下应该一直测试条件。在从wait()方法返回，线程应该一直测试条件来决定是否应该再等待。这是因为另一个线程也可以测试条件并确定等待是不必要的——处理由通知线程设置的有效数据。

当多个线程等待通知时会发生什么情况？调用notify()方法是实际上是哪个线程被唤醒？

这取决于许多因素。Java规范不确定哪个线程被唤醒。在运行时，该线程被唤醒基于几个因素，包括在程序执行过程中的Java虚拟机和调度和时序问题的实现。即使在单个处理器平台上，也无法确定多个线程被唤醒的方式。

就像notify()方法，notifyall()方法不允许我们决定哪个线程被唤醒：他们都被唤醒。当所有的线程被唤醒，可以制定一个机制，线程之间选择那个线程应该继续，那个或者那些线程应该又调用wait()方法继续等待

notifyall()方法是否真正唤醒所有的线程？

是也不是，所有等待的线程唤醒，但他们仍需要获取对象锁。因此线程不能并行运行：它们必须等待对象锁被释放。在一个时间只有一个线程可以运行。

如果只有一个线程要执行，为什么要唤醒所有线程呢？

有几个原因。例如，可能有不止一个条件需要等待。由于我们无法控制哪个线程被唤醒，所以通知完全可以唤醒等待完全不同状态的线程。通过唤醒所有线程，我们可以设计程序，以便线程自行决定下一个线程应该执行什么。另一种选择可能是，当生产者生成能够满足多个消费者的数据时。由于很难确定有多少消费者可以被通知，一个选择是通知他们所有人，让消费者自行处理。

Happy Learning !!

如何使用wait(), notify() and notifyAll() – Java