Re: How to give selective access to the methods in a class?
toton wrote:
Eric Sosman wrote:
toton wrote On 08/09/06 10:24,:
[...]
How much
effective is this in long run? i.e will JIT make the object contains
side by side? or they will be scattered? (boils down to the question,
array holds the object itself or just the reference ? )
The instances exist "somewhere else," and the ArrayList
holds references to them. The instances might be scattered
or might be grouped together; they might even move around to
different memory locations at different times. That's the
JVM's worry, not yours: The reference still leads to the
instance, no matter where it happens to be located.
Yes, its JVM's worry. I know that. My worry is that, do JVM really
worry to keep frequently accessed objects in nearby places?
Not that I know of -- but then, I've never bothered to look.
Also, there is more than one JVM, and different JVMs have different
strategies for managing memory.
The second thing what I wanted to know, for Vector or ArrayList type of
random access container, how much effective the load factor or initial
capacity, as the container doesn't hold the object itself. One need to
choose them judicially for STL containers, whent they contains the
objects itself, otherwise frequent memory copy occures. One can see a
visable performance difference there. Is that kind of fine tuning is
necessary for JCF Vector or ArrayList, (or default value of 10 works
fine irrespective of ArrayList size? ) )as it stores the reference
only, the increase in size out of capicity will cause only copy of
reference, not the object itself.
If you happen to know roughly how many objects the list will
eventually contain, you can save some time by making the list that
large to begin with rather than just letting it grow on its own.
How much time? Probably not a lot unless the list grows quite
large indeed.
I have a
circular buffer which adds several objects from one end and removes
from other end through out the program. It is preferable if the
ArrayList holds the object itself.
The strategy is little different for the program, as you can see. The
program pushes certain objects into the circular buffer, perform some
operation on them and removes the older one. Thus lots of object
created pushed on buffer, and older one removed. So there I see two
problems,
One thing that stands out is the oddity of using an ArrayList
or Vector for a "circular buffer." An ordinary array would seem
more natural. (However, there's a bit of a language barrier here,
and it's quite possibly you use "circular buffer" to mean something
different than I do.)
1) No obvious hotspot, as the program doesn't run with the same object
on the loop (unlike most of the applications, or GUI's). Rather it
looks like a factory conveyor belt, where things are put in, operated
and finished.
2) Little overhead for then gc, as lots of new objects created and
processed need to be garbage collected.
Any tuning for gc can be done? any particular gc suitable for this kink
of oerations?
Toton, have you *measured* a performance problem? Or are
you merely imagining one?
--
Eric Sosman
esosman@acm-dot-org.invalid