Explicit nulling

Question

In what situations in java is explicit nulling useful. Does it in any way assist the garbage collector by making objects unreachable or something? Is it considered to be a good practice?

Answer 1

In general it isn't needed (of course that can depend on the VM implementation). However if you have something like this:

private static final Map<String, String> foo;

and then have items in the map that you no longer need they will not be eligible for garbage collection so you would need to explicitly remove them. There are many cases like this (event listeners is another area that this can happen with).

But doing something like this:

void foo()
{
    Object o;

    // use o

    o = null; // don't bother doing this, it isn't going to help
}

Edit (forgot to mention this):

If you work at it, you should find that 90-95% of the variables you declare can be made final. A final variable cannot change what it points at (or what its value is for primitives). In most cases where a variable is final it would be a mistake (bug) for it to receive a different value while the method is executing.

If you want to be able to set the variable to null after use it cannot be final, which means that you have a greater chance to create bugs in the code.

Answer 2

In Java it can help if you've got a very long-running method, and the only reference to the an object is via a local variable. Setting that local variable to null when you don't need it any more (but when the method is going to continue to run for a long time) can help the GC. (In C# this is very rarely useful as the GC takes "last possible use" into account. That optimization may make it to Java some time - I don't know.)

Likewise if you've got a member field referring to an object and you no longer need it, you could potentially aid GC by setting the field to null.

In my experience, however, it's rarely actually useful to do either of these things, and it makes the code messier. Very few methods really run for a long time, and setting a variable to null really has nothing to do with what you want the method to achieve. It's not good practice to do it when you don't need to, and if you do need to you should see whether refactoring could improve your design in the first place. (It's possible that your method or type is doing too much.)

Note that setting the variable to null is entirely passive - it doesn't inform the garbage collector that the object can be collected, it just avoids the garbage collector seeing that reference as a reason to keep the object alive next time it (the GC) runs.

Answer 3

If you are nulling an object that is about to go out of scope anyway when your method block closes, then there is no benefit whatsoever in terms of garbage collection. It is not unusual to encounter people who don't understand this who work really hard to set a lot of things to null needlessly.

Answer 4

See also WeakReference in J2SE.

Answer 5

From "Effective Java" : use it to eliminate obsolete object references. Otherwise it can lead to memory leaks which can be very hard to debug.

public Object pop(){
    if(size == 0)
        throw new EmptyStatckException();
    Object result = elements[--size];
    elements[size] = null; //Eliminate Object reference
    return result;
}

Answer 6

One special case I found it useful is when you have a very large object, and want to replace it with another large object. For example, look at the following code:

BigObject bigObject = new BigObject();
// ...
bigObject = new BigObject(); // line 3

If an instance of BigObject is so large that you can have only one such instance in the heap, line 3 will fail with OutOfMemoryError, because the 1st instance cannot be freed until the assignment instruction in line 3 completes, which is obviously after the 2nd instance is ready.

Now, if you set bigObject to null right before line 3:

bigObject = null;
bigObject = new BigObject(); // line 3

the 1st instance can be freed when JVM runs out of heap during the construction of the 2nd instance.