Storing Thread events in a Vector

[Vera]

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
}
--------------------------------------------------------------------------