Thread Contention

Question

I've written a producer/consumer type of application. the producer receives data input (speed and time) over a serial connection and places it in a queue of sorts, set up much like the examples at Sun. The consumer picks up the values, calculates a speed and moves an animation object across a display.
I've put both the consumer and producer programs in their own threads. the driver program starts the producer program in its thread and calls an openConnection method to open a serial connection. I then call a startCollecting method that begins reading serial input. The input is dumped in the queue, which has a capacity of 5 values. If the producer fills all five values, it goes into a wait state. the consumer is supposed to pick up the values, freeing the producer to place more values in the queue. My problem is once the producer goes into its wait state, everything freezes, including the driver program interface, and the visual display the consumer is running in.
If I do not call the openConnection and startCollecting separately, but rather just start the producer thread and let it open a connection and start collecting automatically all runs well. It seems the problem exist whenever I attempt to access methods inside the threaded program.
Any help would be greatly appreciated. Have not found any really examples of how to resolve this approach.

Answer 1

I've put both the consumer and producer programs in
their own threads.good.
the driver program starts the
producer program in its thread and calls an
openConnection method to open a serial connection. I
then call a startCollecting method that begins reading
serial input. The input is dumped in the queue, which
has a capacity of 5 values. If the producer fills all
five values, it goes into a wait state. the consumer
is supposed to pick up the values, freeing the
producer to place more values in the queue. My problem
is once the producer goes into its wait state,
everything freezes, including the driver program
interface, and the visual display the consumer is
running in. this sounds like you possibly missed something in the area of thread synchronization. did you invoke notifyAll() after you put somthing in the queue?
the typical queue implementation looks like this:
package farmerworker;
import java.util.*;
* A thread safe queue used to synchronize farmers and workers. Farmers put
* objects into the queue and workers retrieve them. Workers may arbitrarily
* invoke {@link #dequeue()}. Their thread blocks until an instance can be
* retrieved from the queue or the thread is interrupted. <p>
* technically {@link #enqueue( Object )} and {@link #dequeue()} are
* synchronized using {@link #wait()} and {@ #notify()}.
* @author    klemme
* @created   24. September 2001
* @version   $Revision$
public class Queue {
     * Checks whether there are objects in the queue.
     * @return   'true' if there are instances in the queue. WARNING: in a
     *      multithreaded environment it is only reasonable to invoke this
     *      method when holding a lock on this instance, i.e. in a <code>synchronized</code>
     *      block.
    public boolean isEmpty() {
        synchronized ( lock ) {
            return queue.isEmpty();
     * Return the number of objects currently in the queue.
     * @return   a value >= 0
    public int size() {
        synchronized ( lock ) {
            return queue.size();
     * Put an object into the queue.
     * @param obj  the instance to enque
    public void enqueue( Object obj ) {
        synchronized ( lock ) {
            queue.add( obj );
            lock.notify();
     * Retrieve something from the queue. This method blocks until either an
     * Object can be retrieved from the queue or this thread is interrupted.
     * @return                          the next Object in the queue
     * @exception InterruptedException  in case of premature termination of this
     *      thread.
    public Object dequeue()
        throws InterruptedException {
        synchronized ( lock ) {
            while ( isEmpty() ) {
                lock.wait();
            return queue.remove( 0 );
    private List queue = new LinkedList();
     * The lock on which this instance synchronizes.
    protected final Object lock = queue;
[/code}]instead of synchronizing on "lock" you can just synchronize methods.  then you have to invoke notifyAll() and wait() on "this".  you can also change the conditions when the queue accepts new input.  this Queue is unbounded, but you can implement a size limit via a condition testing for the size in enqueue(). (typically this is easier done then working with a ring buffer in a fixed sized array, since then you need two indexes etc. and the overhead of a LinkedList is not too big. - btw: LinkedList is faster than ArrayList if you don't need indexed access like in this case.)
regards
robert