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

Posted Jiakeqiang

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了如何使用wait(), notify() and notifyAll() – Java相关的知识,希望对你有一定的参考价值。

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的主要内容,如果未能解决你的问题,请参考以下文章

在这段代码中,如何使用 notify 调用 wait() 调用?

并发编程之 wait notify 方法剖析

如何在没有IllegalMonitorStateException的Java中使用wait和notify?

java中使用wait()和notify()的简单场景

Wait()、Notify()、定时器和 Jbuttons

wait和notify方法的使用