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
}

--------------------------------------------------------------------------