First of all, thanks to all that have helped this beginning Java
programmer with my questions in the past. I'm hoping that once again
the experts here can save my butt!

I have a working implementation using LinkedBlockingQueues in a
producer to multiple consumers model. I have successfully crashed on
heap memory without much trouble, though. I've written all the offer()
and poll() routines to have timouts when blocked. Problem is, I can't
figure out how to make the LinkedBlockingQueues block!

The queues are passing lists of objects between them. A list can have
any number of objects in them, but at least 1. So, starting at the
basics and building up, an object is defined as having an interface:

public interface AnObjectInterface {
    public HashMap<String, String> hmTime = new HashMap<String, String>();
}

..and the object being:

public class AnObject implements Serializable, AnObjectInterface {
    static final long serialVersionUID = 1; // needed for serializable..
    public LinkedHashMap<String, String> hmTime = new
LinkedHashMap<String, String>(); // time, comment
}

hmTime is written to by each producer & consumer, like a log. So the
class that is the list of objects is:

public class ObjectList implements Externalizable {
    static final long serialVersionUID = 1;
    public ObjectList(){}
    /*
    * This LinkedList holds the actual objects
    */
    public LinkedList<AnObject> objectList = new LinkedList<AnObject>();

    [methods writeExternal and readExternal mercifully ommitted :)]
}

Now as we're working up the heirarchy, this class is used to create the
actual queues that are given to the producers and consumers:

public class ObjectListQueue extends LinkedBlockingQueue<ObjectList> {
    static final long serialVersionUID = 1;
}

Messing with the above class for 2 days to constrain the size of the
LinkedBlockingQueue has created zero joy!

So those are all the actors (except for the actual producers and
consumers). So the following is currently used to create the queues:

(In this simple example-which works-there is an object generator, a
single interim consumer/producer, and a final consumer. P = producer,
CP = producer/consumer, C = consumer)

P -> CP -> C

[...]
ObjectListQueue qCPin = new ObjectListQueue(), qCin  = new
ObjectListQueue();
// outbound queues (arrays, with each destination as an element)
ObjectListQueue[] aGout  = {qCPin}, aCPout = {qCin};
[...]

Now all that is left to hand things off to the players:

ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new ObjectListGenerator(aGout));
exec.execute(new ObjectListConsumerProducer(qCPin, aCPout));
exec.execute(new ObjectListConsumer(qCin));

Thats it. It all works great. Problem is when either the
ObjectListConsumerProducer or ObjectListConsumer process (consume)
slowly, the queue gradually grows (really?!). When the heap gets down
to about 470k, the queues crash. FYI, no command line changes except
"-server". This equates to about 13,000 lists of 10 objects each in a
single LinkedBlockingQueue.

So I guess I'm beating my head on the keyboard trying to figure out how
to make the blocking queues block! The error might be in the way I've
got the whole app structured, or in how I'm initializing the
LinkedBlockingQueues. I've tried all I can think of, including
generics, but probably poorly as I feel I'm sitting here with all my
references opened up jumping from one approach to another blindly,
hoping one will show some promise.

Please forgive me if there are subtle typos, as I reduced the actual
code to only include those sections of interest, and may have
accidentally made a typo. I hope its obvious that the code does in fact
work.

Thanks VERY much in advance!

Bogus Exception