CODEWITHSUNDEEP
javaperformancememory
Woot4Moo
Woot4Moo

Reputation: 24316

Java Collection#clear reclaim memory

With the following function: Collection#clear

how can I attempt to reclaim memory that could be freed from an invocation? Code sample:

public class Foo
{
    private static Collection<Bar> bars;
    public static void main(String[] args){
        bars = new ArrayList<Bar>();  
        for(int i = 0; i < 100000;i++)
        {  
            bars.add(new Bar());
        }      
         bars.clear();  
         //how to get memory back here
    }
}

EDIT

What I am looking for is similar to how ArrayList.remove reclaims memory by copying the new smaller array.

Upvotes: 0

Views: 160

Answers (4)

Veronica Cornejo
Veronica Cornejo

Reputation: 488

bars= null ;

would be the best. clear doesn't guarantee to release any memory, only to reset the logical contents to "empty".

In fact, bars= null ; doesn't guarantee that memory will be immediately released. However, it would make the object previously pointed by bars and all its dependents "ready for garbage collection" ("finalization", really, but let's keep this simple). If the JVM finds itself needing memory, it will collect these objects (other simplification here: this depends on the exact garbage collection algorithm the JVM is configured to use).

Upvotes: 2

Jim Garrison
Jim Garrison

Reputation: 86774

You can't force memory reclamation, that will happen when garbage collection occurs.

If you use clear() you will clear the references to objects that were contained in the collection. If there are no other references to those objects, then they will be reclaimed next time GC is run.

The collection itself (which just contains references, not the objects referred to), will not be resized. The only way to get back the storage used by the collection is to set the reference bars to null so it will eventually be reclaimed.

Upvotes: 0

Peter Lawrey
Peter Lawrey

Reputation: 533500

It is more efficient to only reclaim memory when you need to. In this case it is much simpler/faster to let the GC do it asynchronous when there is a need to do. You can give the JVM a hint using System.gc() but this is likely to be slower and complicate your program.

how ArrayList.remove reclaims memory by copying the new smaller array.

It doesn't do this. It never shrinks the array, nor would you need to.

If you really need to make the collection smaller, which I seriously doubt, you can create a new ArrayList which has a copy of the elements you want to keep.

Upvotes: 3

SLaks
SLaks

Reputation: 887413

You can't.

At some point after there are no more references to the objects, the GC will collect them for you.

EDIT: To force the ArrayList to release its reference to the giant empty array, call trimToSize()

Upvotes: 0

Related Questions