Hi,
 I have a typical situation for the main backbone of the program. In
my program, lots of new objects gets created, added in the processing
queue ,used and removed from the queue. Something like a air-traffic
control system or moving average.
 The objects added to the queue, are by nature immutable, and that
"may help" in a threaded environment (but not very much as the
processing queues are seperate). However added immutability cause them
to be use-and throw objects. While mutability cause them to be reused.
 I am trying to demonstrate the problem with a short example. While
the original problem is much complex, but the underlying working
principle is more or less same.
public class TestProcess{
    public static void main(String[] args){
        Deque<ObjectTobeProcessed> queue = new
ArrayDeque<ObjectTobeProcessed>(10);
        for(int i = 0; i <10; ++i){///pre existing objects.
            queue.addFirst(new ObjectTobeProcessed());
        }
        long time1  = System.currentTimeMillis();
        for(int i = 0; i <10000000; i++){
            queue.removeLast();///remove the last one.
            queue.addFirst(new ObjectTobeProcessed());///add a new at the first.
            process(queue);
        }
        long time2 = System.currentTimeMillis();
        System.out.println ("time "+(time2-time1)*0.001);

        Deque<MutableObjectTobeProcessed> queue1 = new
ArrayDeque<MutableObjectTobeProcessed>(10);
        for(int i = 0; i <10; ++i){///pre-existing objects.
            queue1.addFirst(new MutableObjectTobeProcessed());
        }
        time1 = System.currentTimeMillis();
        for(int i = 0; i <10000000; i++){
            queue1.getLast().setValue();
            process(queue);
        }
        time2 = System.currentTimeMillis();
        System.out.println ("time "+(time2-time1)*0.001);
    }
    public static void process(Deque<ObjectTobeProcessed> queue){
        double sum = 0;
        for(ObjectTobeProcessed o:  queue ){
            sum+= o.getValue();
        }
    }
}
class ObjectTobeProcessed{
    private double value;
    public ObjectTobeProcessed(){
        value = Math.random();
    }
    public double getValue(){
        return value;
    }
}
class MutableObjectTobeProcessed{
    private double value;
    public MutableObjectTobeProcessed(){
        value = Math.random();
    }
    public double getValue(){
        return value;
    }
    public void setValue(){
        value = Math.random();
    }
}
Here two class creates some random number, while one allows to reset
its state , the other do not.
In the first case one number is removed from last, one created at
first, and some process is called (here a moving average! ) . Here a
large numver of objects created, used and thrown away. In the second
case, it mutates the last object (which is supposed to be thrown away)
to the new state. Here no object gets created and destroyed at all!.
Here the queue sequence is not the same (that don not affect the
moving average though), but that can be solved using a wrapped version
of deque (with a modulo wrapping).
There is a difference for first case and second case, and difference
increases considerabily when the objects becomes complex and stores
more than premitive types.
In the actual problem, the existing size is not fixed (as 10 here) but
nearly fixed  within certain limit.
And the objects come & go from the processing queue are not so small.
And the system is supposed to be on for ever and process things as come
and go away.
The things I notice,
1) Both version has clear hotspot for processing.
2) only the second verson has hotspot for processing over same data.
3) For second version GC has very less job compared to first one.
In actual case, the objects are characters (handwritten, not printed ,
thus they can not be formed from same set of objects). Mutating them
means one can unknowingly or by mistake form a B from and A! Making
them immutable means an easier and cleaner code, but error prone (as
Java doesn't have a const , so I even can't constantify an mutable
object when needed)
Also I use Mysaifu JVM for PocketPC, which may not have as
sophisticated GC as sun's one .Though still I hadn't tested the code
there with a performance difference ,  I will do it in near future (my
friend had take my iPAQ :( , sure he will return it by this weekend.
Can anyone give a little more insight, and the best way to do such job?
(The processing is pretty computational gemetry related and also has
some signal processing aspect. in short instead of moving average, it
is some sot of complex mathematical calculation comes into process).
Any alternate / better way to do such job ? Something like I can have a
mutable object but selectively constantify it when needed?

Thanks for any kinds of suggestion / advice