What are some Java memory management best practices? [closed]

Answer 1

The first example is fine. There isn't any memory allocation going on there, other than a stack variable allocation and deallocation each time through the loop (very cheap and quick).

The reason is that all that is being 'allocated' is a reference, which is a 4 byte stack variable (on most 32 bit systems anyway). A stack variable is 'allocated' by adding to a memory address representing the top of the stack, and so is very quick and cheap.

What you need to be careful of is for loops like:

for (int i = 0; i < some_large_num; i++)
{
   String something = new String();
   //do stuff with something
}

as that is actually doing memory allocatiton.

Answer 2

If you haven't already, I suggest installing the Eclipse Test & Performance Tools Platform (TPTP). If you want to dump and inspect the heap, check out the SDK jmap and jhat tools. Also see Monitoring and Managing Java SE 6 Platform Applications.

Answer 3

The first loop is better. Because

• the variable something will be clear faster (theoretical)
• the program is better to read.

But from point of memory this is irrelevant.

If you have memory problems then you should profile where it is consumed.

Answer 4

Those two loops are equivalent except for the scope of something; see this question for details.

General best practices? Umm, let's see: don't store large amounts of data in static variables unless you have a good reason. Remove large objects from collections when you're done with them. And oh yes, "Measure, don't guess." Use a profiler to see where the memory is being allocated.

Answer 5

"Am I incorrect to say that the bottom loop is better?", the answer is NO, not only is better, in same case is necessary... The variable definition (not the content), is made in Memory heap, and is limited, in the first example, each loop create an instance in this memory, and if the size of "arrayOfStuff" is big, can occur "Out of memory error:java heap space"....

Answer 6

In my opinion, you should avoid micro-optimizations like these. They cost a lot of brain cycles, but most of the time have little impact.

Your application probably has a few central data structures. Those are the ones you should be worried about. For example, if you fill them preallocate them with a good estimate of the size, to avoid repeated resizing of the underlying structure. This especially applies to StringBuffer, ArrayList, HashMap and the like. Design your access to those structures well, so you don't have to copy a lot.

Use the proper algorithms to access the data structures. At the lowest level, like the loop you mentioned, use Iterators, or at least avoid calling .size() all the time. (Yes, you're asking the list every time around for it's size, which most of the time doesn't change.) BTW, I've often seen a similar mistake with Maps. People iterate over the keySet() and get each value, instead of just iterating over the entrySet() in the first place. The memory manager will thank you for the extra CPU cycles.