I fear exactly this is going to happen. I wonder what other "optimizations"
of that kind you will find in the code....

Jan

    All right, tell them it's pointless.  It's pointless
for more than one reason:

    - First, setting `rs = null' affects only the method's
own copy of the argument value, and does not affect any copies
the caller might have.  If the caller does

    ResultSetMetadata myRs = ...;
    closeResultSetMetaData(myRs);

then myRs is not changed at all.  The object myRs refers to
is still "live" and is not eligible for garbage collection;
the method has made no change whatever in its status.

    - Second, the try/catch block is pointless, because there
is nothing in `rs = null' that can throw an Exception.  The
writer of the try/catch was a seriously confused person.

    - Third, setting all the references to a particular object
to null does not avoid garbage collection, it just makes the
object eligible for collection.  If the JVM decides to run the
garbage collector it will do so, and the collector may reclaim
the garbage object's memory.  "Clearing up the memory faster"
is almost entirely bogus; all that might happen is that the
memory could be reclaimed sooner.  Sooner != faster.

    (The "almost" is because some garbage collectors must
work harder to reclaim long-lived objects than those that die
young.  Setting all the references to null -- or pointing them
at other objects, or letting the references themselves die --
makes the object garbage, and making it garbage sooner rather
than later might let it get collected on the next GC instead
of on the one after it.  Thus the effective lifetime might
be shortened and the collector might therefore work a little
less hard -- but this is an effect so small it would be hard
to measure.)

    A suggestion: If your compatriots are so convinced that
their method produces a performance improvement, challenge them
to measure the size of the improvement by actual experiment.
Run the code with the method as it stands and run it again with
the guts of the method commented out, and ask them how much
difference it made.  My bet: If the measurement is done with
great care, the commented-out version will run just a hair
faster than the "optimized" original.

I fear you're being taken for a ride.  Developer is charging for
un-maintainable code.  I'd cancel their contract immediately.

Sorry but that's what you get for going off shore.

Start writing your article for www.thedailywtf.com !

Arne

It depends how it was created.  If it were passed as a parameter, the
caller may have created it as an expression, holding no handle to it
other than the passed parameter which can be nullified.

If it were created in the current method, the caller knows nothing
about it.

If the caller allocated it, pointed to it with its own local variable
and passed it as a parameter, than the callee nullifying the reference
would not do any good.

Happily nullifying a reference is a fairly quick operation.