Multithreading - Problem with notifyAll() and wait()

I have a program which has 2 threads: producer and consumer. Producer
sleeps, wakes up and outputs how long it slept and what time it woke
up. That info is passed to a vector. Consumer then gets that info from
the vector and prints it out. Well, at least that's what it should do.

Right now it gives me a runtime error because it doesn't like the
NotifyAll() and wait() statements (producer notifies and consumer
waits). It gives me an IllegalMonitorStateException for both - notify
and wait, saying that "current thread is not the owner."

Can anyone tell me what is wrong with this? I really have no idea.

// Import libraries
import java.util.Random;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;
import java.util.Vector;

public class Assignment3b
{
      private Queue queue = new Queue();
      Vector vectorQueue = new Vector();
      String eventInfo;

      // Create threads:
      private ProducerThread producer = new ProducerThread();
      private ConsumerThread consumer = new ConsumerThread();

      /** Main method */
      public static void main(String[] args)
      {
            new Assignment3b();
      }

      public Assignment3b()
      {
            // Start threads
            producer.start();
            consumer.start();

      }/* End Main method */

      /** Method to get time of an event */
      public String getTimeOfEvent()
      {
          // Make a new Date object, which will be initialized to the
current time
          Date now = new Date();

          // This will output the hour (0-12), minutes, seconds,
milliseconds,
          // and the am/pm marker.
          SimpleDateFormat format = new SimpleDateFormat("hh:mm:ss:SS
a");

          String outputTime = format.format(now);

          return outputTime;
      } /* End of getTimeOfEvent method */

      /***********Producer Thread *****************/
      class ProducerThread extends Thread
      {
            int sleepTime;
            String wakeTime;

            public void run()
            {
                  while(true)
                  {
                        // Interrupt Consumer thread
                          consumer.interrupt();

                        // Loop Producer thread 10 times
                        for (int count = 0; count < 10; count++)
                        {
                              // Generate random number between 10 and
2000
                          sleepTime = (int)(2000.0 * Math.random()) +
10;

                              // Put the thread to sleep for a random
                              // amount of milliseconds
                                try
                                {
                                      Thread.sleep(sleepTime);
                                }

                                catch(InterruptedException ex)
                                {
                                      ex.printStackTrace();
                                }

                                // Save the time when producer woke up
                                wakeTime = getTimeOfEvent();

                                // Store both times into a variable
                                eventInfo = "nProducer slept for " +
sleepTime +
                                      " milliseconds, and woke up at "
+ wakeTime;

                              // Store the event information in the
vector
                              queue.storeEventInfo(eventInfo);

                                // Wake up the consumer thread
                                notifyAll();
                        }
                  }
            }
      }

      /*********** Consumer Thread *************/
      class ConsumerThread extends Thread
      {
            public void run()
            {
                  try
                  {
                        // Make the thread wait while the queue is
empty
                        while(vectorQueue.isEmpty())
                        {
                              wait();
                        }
                  }

                  catch(InterruptedException ex)
                  {
                        ex.printStackTrace();
                  }

                  // Output the event information produced by Producer
thread
                  while(true)
                  {
                        for(int count = 0; count < vectorQueue.size();
count++)
                        {

System.out.println(vectorQueue.elementAt(count));
                        }
                  }
            }
      }

      /*********** Inner class for queue *************/
      class Queue
      {
            public String getEventInfo()
            {
                  return eventInfo;
            }

            public synchronized void storeEventInfo(String event)
            {
                  eventInfo = event;

                  // Add new event to the queue
                  vectorQueue.addElement(eventInfo);

                  // Notify other threads
                  notifyAll();
            }
      }
}