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

Answer 1

The JVM is best at freeing short-lived objects. Try not to allocate objects you don't need. But you can't optimize the memory usage until you understand your workload, the object lifetime, and the object sizes. A profiler can tell you this.

Finally, the #1 thing you must avoid doing: never use Finalizers. Finalizers interfere with garbage collection, since the object can't be just freed but must be queued for finalization, which may or may not occur. It's best to never use finalizers.

As for the memory usage you're seeing in Eclipse, it's not necessarily relevant. The GC will do its job based on how much free memory there is. If you have lots of free memory you might not see a single GC before the app is shut down. If you find your app running out of memory then only a real profiler can tell you where the leaks or inefficiencies are.

Answer 2

Don't try to outsmart the VM. The first loop is the suggested best practice, both for performance and maintainability. Setting the reference back to null after the loop will not guarantee immediate memory release. The GC will do its job best when you use the minimum scope possible.

Books which cover these things in detail (from the user's perspective) are Effective Java 2 and Implementation Patterns.

If you care to find out more about performance and the inners of the VM you need to see talks or read books from Brian Goetz.

Answer 3

Well, the first loop is actually better, because the scope of something is smaller. Regarding memory management - it makes not a big difference.

Most Java memory problems come when you store objects in a collection, but forget to remove them. Otherwise the GC makes his job quite good.

Answer 4

As one poster above suggested, use profiler to measure the memory (and/or cpu) usage of certain parts of your program rather than trying to guess it. You may be surprised at what you find!

There is an added benefit to that as well. You'll understand about your programming language and your application more.

I use VisualVM for profiling and recommend it greatly. It comes with jdk/jre distribution.

Answer 5

From what I understand you are looking at, the bottom loop is no better. The reason being even if you are trying to reuse a single reference (Ex- something), the fact is the object (Ex - arrayOfStuff.get(i)) is still being referenced from the List (arrayOfStuff). To make the objects eligible for collection, they should not be referenced from any place. If you are sure about the life of the List after this point, you may decide to remove/free the objects from it, within a separate loop.

The optimization that can be done from a static perspective (ie no modification is happening to this List from any other thread), it's better to avoid the size() invocation repeatedly. That is if you are not expecting the size to change, then why calculate it again and again; after all it is not an array.length, it is list.size().

Answer 6

The two loops will use basically the same amount of memory, any difference would be negligible. "String something" only creates a reference to an object, not a new object in itself and thus any additional memory used is small. Plus, compiler / combined with JVM will likely optimize the generated code anyway.

For memory management practices, you should really try to profile your memory better to understand where the bottlenecks actually are. Look especially for static references that point to a big chunk of memory, since that will never get collected.

You can also look at Weak References , and other specialized memory management classes.

Lastly, keep in mind, that if an application takes up memory, there might be a reason for it....

Update The key to memory management is data structures, as well as how much performance you need / when. The tradeoff is often between memory and CPU cycles.

For example, a lot of memory can be occupied by caching, which is specifically there to improve performance since you are trying to avoid an expensive operation.

So think through your data structures and make sure you don't keep things in memory for longer than you have to. If it's a web app, avoid storing a lot of data into the session variable, avoid having static references to huge pools of memory, etc.