Thread: Java Garbage Collection and destructors

1. Garbage Collector
Garbage collection is a way for the JVM to clean the heap. The heap is where all referenced objects live. Primitives like int and double aren't really objects in the same way as types so therefore they aren't garbage collected. There is no definite answer to how the garbage collector works.

If you wish to read up on the memory mangement in Java, have a look at http://java.sun.com/j2se/reference/w...whitepaper.pdf

Here is an extract from The Java Language Environment

2.1.6 Memory Management and Garbage Collection
C and C++ programmers are by now accustomed to the problems of explicitly managing memory: allocating memory, freeing memory, and keeping track of what memory can be freed when. Explicit memory management has proved to be a fruitful source of bugs, crashes, memory leaks, and poor performance.
Java technology completely removes the memory management load from the programmer. C-style pointers, pointer arithmetic, malloc, and free do not exist. Automatic garbage collection is an integral part of Java and its run-time system. While Java technology has a new operator to allocate memory for objects, there is no explicit free function. Once you have allocated an object, the run-time system keeps track of the object's status and automatically reclaims memory when objects are no longer in use, freeing memory for future use.

Java technology's memory management model is based on objects and references to objects. Java technology has no pointers. Instead, all references to allocated storage, which in practice means all references to an object, are through symbolic "handles". The Java technology memory manager keeps track of references to objects. When an object has no more references, the object is a candidate for garbage collection.

Java technology's memory allocation model and automatic garbage collection make your programming task easier, eliminate entire classes of bugs, and in general provide better performance than you'd obtain through explicit memory management. Here's a code fragment that illustrates when garbage collection happens:

 class ReverseString {
    public static String reverseIt(String source) {
        int i, len = source.length();
        StringBuffer dest = new StringBuffer(len);
 
        for (i = (len - 1); i >= 0; i--) {
            dest.appendChar(source.charAt(i));
        }
        return dest.toString();
    }
}

The variable dest is used as a temporary object reference during execution of the reverseIt method. When dest goes out of scope (the reverseIt method returns), the reference to that object has gone away and it's then a candidate for garbage collection.

2.1.7 The Background Garbage Collector
The Java technology garbage collector achieves high performance by taking advantage of the nature of a user's behavior when interacting with software applications such as the HotJavaTM browser. The typical user of the typical interactive application has many natural pauses where they're contemplating the scene in front of them or thinking of what to do next. The Java run-time system takes advantage of these idle periods and runs the garbage collector in a low priority thread when no other threads are competing for CPU cycles. The garbage collector gathers and compacts unused memory, increasing the probability that adequate memory resources are available when needed during periods of heavy interactive use.
This use of a thread to run the garbage collector is just one of many examples of the synergy one obtains from Java technology's integrated multithreading capabilities--an otherwise intractable problem is solved in a simple and elegant fashion.

2. Destructors
Surprise perhaps but there is sort of a concept of destructors in Java and its a method which every object inherits from the class Object. The method is called finalize() and is run only once by the garbage collector before it cleans up the object. There is no real reason to clean up all your objects using this method though because the garbage collector will automatically clean up any other objects that become unreferenced as the first object gets cleaned up.

Here is an override of the finalize mehotd.

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }

For some more information on finalize and garbage collection have a look at Java Programmer's SourceBook : Thinking in Java

// Json

Ahh, good old C++.

Yes, destructors are useless in Java because in Java you don't need to explicitly tell the computer you're done with a bit of memory when it goes out of scope. Java's Garbage Collector takes care of any memory release that was allocated by your program.

A visualization of this concept is this:

Say you're using some tools. In both C++ and Java, every time you create an object is analogous to getting a new tool. The garbage collector in Java can be viewed as the Professor in the lab who occasionally comes around, picking up the tools no one's using and returning them to the tool closet. However, C++ doesn't have this person coming around cleaning up the workshop, so you must put it back yourself (the destructor). If you don't, the tool will continue to sit on the workbench, so when someone wants to use that tool and goes to look for it in the tool closet, it isn't there.

Note this, though: The professor will always pick up tools he thinks no one is using, and he's quick about it. As soon as you set the tool down, he picks it up and returns it to the tool closet. In Java, this is similar to an object becoming un-referenced. The garbage collector sees that the object has no one pointing to it for use, and instantly reclaims the memory. Exactly how this is implemented on a low level is beyond my knowledge, and I think it still might be proprietary information, or it could have been released as open source with the OpenJDK project.