Very slow garbage collection when overriding finalize

Question

I am working on a 3D visualization program, and smooth animation is very important; long pauses for GC is unacceptable.
GC is normally very fast, but when I tried to override finalize() to do some necessary cleanup this is no longer the case. I wrote a simple test application to verify this behaviour (included below), and ran it with java -verbose:gc.
Here is the output when commenting out finalize():
[GC 511K->248K(1984K), 0.0035095 secs]
[GC 760K->265K(1984K), 0.0016098 secs]
[GC 777K->265K(1984K), 0.0010843 secs]
[GC 777K->265K(1984K), 0.0009727 secs]
[GC 777K->265K(1984K), 0.0006170 secs]
[GC 777K->265K(1984K), 0.0005789 secs]
[GC 777K->265K(1984K), 0.0005970 secs]
[GC 777K->265K(1984K), 0.0006351 secs]
And here is the same when overriding finalize():
[GC 511K->285K(1984K), 0.0042582 secs]
[GC 797K->797K(1984K), 0.0120764 secs]
[GC 1309K->1260K(1984K), 0.0106945 secs]
[GC 1772K->1772K(2368K), 0.0124083 secs]
[Full GC 1772K->900K(2368K), 0.0306330 secs]
[GC 1412K->1412K(2080K), 0.0106363 secs]
[GC 1924K->1920K(2464K), 0.0111980 secs]
[Full GC 1920K->908K(2464K), 0.0318079 secs]
Can someone explain what is going on? I assume Java is doing quite a lot of work just in order to run my finalize, but this seems a bit much; the GC time is two orders of magnitude slower!
I am running SUN Java 1.4 under Linux.
My test application:
class C
    int i;
    int[] a = new int[20];
    public C(int i)
        this.i = i;
        for (int j=0; j<a.length; j++) a[j] = i*j;
    protected void finalize() {
        if (i > 200) return;
class gctest
    public static void main(String[] args)
        C[] c = new C[500];
        for (int i=0; i < 100000; i++) {
            c[i%c.length] = new C(i);
            long l = System.currentTimeMillis()+1;
            while (System.currentTimeMillis() < l);
}Thanks.
Kristian Eide

Answer 1

Let me keep it simple. gussev is correct.
Do NOT use finalize. I don't know what that other poster read that suggested in rare cases finalize is needed. Finalize can never be usefull for anything but hints at when your class has been "finalized."
You must use something from the java.lang.ref package. It has been said that finalize is not guaranteed to run. For you I am assuming it means a memory leak. If it does not mean a memory leak because when the java process is done, the c++ process will always be done too, then you can use finalize, but its not recommended. Yes, when your object has a finalize method defined, it will delay its collection. Normally if their is no finalize method the GC will just collect the object, but if their is a finalize, the GC has to consider that this may take time, so it can postpone GC until it feels it has time, or it has no choice. looking at your output and the addition of the word "Full GC" to the second set, I am assuming the GC has postponed as long as it can and when it finally runs, its collecting a nice size set of objects.
Suck it up, bite the bullet, take courage, do what you gotta do, etc. etc... Forget about finalize :D I think a WeakReference is likely most appropriate for your application. You may need to make your own thread that cleans up these objects though, and give it a lower priority than your drawing thread. In essence you will be determining when finalize is run so to speak as opposed to letting the GC, and you are smarter than the GC, or at least thats the idea :)
This should get you started
http://developer.java.sun.com/developer/technicalArticles/ALT/RefObj/