Storing Thread events in a Vector

I have a thread (Producer) that is supposd to sleep for a random amount
of time, record it in a vector and wake up another thread (Consumer).
That thread should read the elements from the vector when the first
thread (Producer) is done writing to it.

So, can't figure out how to get the Consumer thread to see the elements
in the vector. Right now it doesn't print anything because Consumer for
some reason doesn't see the vector elements.

Here's what I have:

-----------------------------------------------------------------------
// 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 Assignment3
{
    // Create threads:
    ProducerThread producer = new ProducerThread();
    ConsumerThread consumer = new ConsumerThread();

    // Create a vector
    Vector queue = new Vector();

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

    public Assignment3()
    {
        // Start producer thread
        producer.start();

        // Start consumer thread
        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

/////////////////////// The Producer Thread class
////////////////////////////
    class ProducerThread extends Thread
    {
         int sleepTime=0;
         String wakeTime=null;

         // Construct a thread for producer
         public ProducerThread()
         {
         }

          // Override the run() method to tell the system what the thread
will do
          public synchronized void run()
          {

            // 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)
               {
               }

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

               // Store the time string in the vector array
               queue.add("\nProducer slept for " + sleepTime +
               " milliseconds, and woke up at " + wakeTime);

               // Print the vector element
               //System.out.println(queue.elementAt(count));

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

          }
    } // End ProducerThread class

///////////////////////////// The Consumer Thread class
///////////////////////
    class ConsumerThread extends Thread
    {
        // eventInfo stores the time producer slept and when it woke up
        String eventInfo;

        // Construct the Consumer thread
         public ConsumerThread()
         {
         }

         // Override the run() method to tell the system what the thread will
do
          public synchronized void run()
          {
           try
           {
               while(!queue.isEmpty())
               {
                    consumer.wait();

                    // While count doesn't exceed queue size, print each
                    // element in the queue.
                    for(int count = 0; count < queue.size(); count++)
                    {
                        System.out.print(queue.elementAt(count));
                    }
           }
           }

           catch (InterruptedException ex)
           {
           }

          }
    } // End ConsumerThread class
}
--------------------------------------------------------------------------