timothy ma and constance lee said:
Sir/madam
I have this question in my heart.
Other people answered your question, but I wonder if they were assuming you
knew more than you do. So let me make a few points clear in case you don't
understant the basics of garbage collection.
In Java, they always say object use up
the memory. Since all java programming will have object instiantiate like
Date(), timestamp, String etc. Should we need to garbage collect them
after use?
No. It's all automatic. You don't have to worry about that.
if you do something like:
for (int i=0; i < 1000000; i++) {
Date d = new Date();
// do stuff with date
}
It will create a million Date objects for you, but each Date object is lost
at the end of each iteration of the for() loop, and as such, they are
available for the garbage collector to free them. The garbage collector
runs automaitcally when it's needed so you just don't worry about it.
However, the better way to write that is something like this (as someone
else already suggested to you):
Date d = new Date();
for (int i=0; i < 1000000; i++) {
// keep reusing the one Date object for each loop
}
Then you only use up the memory for one Date object and only one Date
object has to be cleaned up after your method terminates. So as a general
rule, it's better if you don't create lots of objects inside large loops if
you don't need to. But at the same time, Java object creation and cleanup
is so fast, you can normally get away with doing it the bad way.
If so, how to do that by batch rather than object bu object?
The garbage collector will clean up your dead objects for you at some point
in the future. You normally never have to worry about it. That's the
beauty of using a gc based language like Java.
You can force the garbage collector to run by calling System.gc() at any
point, but you never need to do that unless you have very special
requirements. It runs automatically when it's needed.
If you have data you don't need anymore, you can drop your access to it by
setting the object to null. So for example:
int a[] = new int[10000000];
Uses up a large chunk of memory which won't be freed as long as you can
access the variable a. But if you are done with the data, you can drop your
access to the array by doing this:
a = null;
At that point, all the memory used to hold the large array is available for
the gc() to reclaim when it needs more memory.
Normally however, you don't even do that, instead, you just make sure the
life of the variable matches the programs need for the data. If you only
need that large data for the life of a single method, then you make it a
local variable in the method. If you only needed it for the life of a
given object, you make it an instance variable in the object.
When you might find a need for that is for class variables (static). They
stay around for the life of your program, and if there's some point in the
program you don't need them anymore, you can make the memory available for
other use just by setting it to null like above.
As someone else said, the normal practice is to not worry about it until it
becomes a problem. If you are used to programing in other languages where
you have to carefully alloc and free all your memory and spend all your
life hoping you haven't created a memory leak, it's hard at first to get
used to ignoring it. But once you get used to the beauty of not having to
worry about memory, you will never want to go back.
