Garbage Collection In Java

Garbage collection in Java

In this article we are going to describe the most popular concept of Java; Garbage Collection. In this article, we describe what garbage collection is, why garbage collection is used and the benefit of garbage collection, etc.

What is Garbage Collection?

In computer science, garbage collection (GC) is a form of automatic memory management. The garbage collector, or just collector, attempts to reclaim garbage or memory occupied by objects that are no longer in use by the program. Since objects are dynamically allocated using the new operator, you might be wondering how such objects are destroyed and their memory released for later reallocation. In some languages, such as C++, dynamically allocated objects must be explicitly released by use of a delete operator. Java takes a different approach; it handles de-allocation for you automatically. The technique that accomplishes this is called garbage collection. It works like this: when no references to an object exist, that object is assumed to be no longer needed, and the memory occupied by the object can be reclaimed. There is no explicit need to destroy objects as in C++. Garbage collection only occurs sporadically (if at all) during the execution of your program. It will not occur simply because one or more objects exist that are no longer used. Furthermore, different Java run-time implementations will take varying approaches to garbage collection, but for the most part, you should not have to think about it while writing your programs.

Why use garbage collection?

Some important point

The Java Heap is divided into three generations for the sake of garbage collection. These are the young generation, tenured or old generation, and the Perm area.
New objects are created in the young generation and subsequently moved to the old generation.
A String pool is created in the Perm area of the Heap; garbage collection can occur in perm space but depends upon JVM to JVM.
Minor garbage collection is used to move objects from Eden space to Survivor 1 and Survivor 2 space and major collection is used to move an object from young to tenured generation.
Whenever Major Garbage Collection occurs application threads stop during that period which will reduce the application's performance and throughput.
There are a few performance improvements used in garbage collection in java 6 and we usually use JRE 1.6.20 for running our application.
The JVM command-line options –Xmx and -Xms are used to set up the starting and max size for the Java Heap. The ideal ratio of this parameter is either 1:1 or 1:1.5 based upon my experience; for example, you can have either both –Xmx and –Xms as 1GB or –Xms 1.2 GB and 1.8 GB.
There is no explicit way of doing garbage collection in Java.

Use of finalize method

Sometimes an object will need to perform some action when it is destroyed. For example, if an object is holding some non-Java resource such as a filehandle or window character font, then you might want to make sure these resources are freed before an object is destroyed. To handle such situations, Java provides a mechanism called finalization. By using finalization, you can define specific actions that will occur when an object is just about to be reclaimed by the garbage collector.

To add a finalize to a class, you simply define the finalize( ) method. The Java run time calls that method whenever it is about to recycle an object of that class. Inside the finalize( ) method you will specify those actions that must be performed before an object is destroyed. The garbage collector runs periodically, checking for objects that are no longer referenced by any running state or indirectly through other referenced objects. Right before an asset is freed, the Java run time calls the finalize() method on the object.

Syntax of the finalize method

protected void finalize( )
{
// finalization code here
}

Explanation of this code

Here, the keyword protected is a specifier that prevents access to finalize( ) by code defined outside its class. It is important to understand that finalize( ) is only called just prior to garbage collection. It is not called when an object goes out-of-scope, for example. This means that you cannot know when, or even if, finalize( ) will be executed. Therefore, your program should provide other means of releasing system resources, etc., used by the object. It must not rely on finalize( ) for normal program operation.

Note

If you are familiar with C++, then you know that C++ allows you to define a destructor for a class, which is called when an object goes out-of-scope. Java does not support this idea or provide for destructors. The finalize( ) method only approximates the function of a destructor. As you get more experienced with Java, you will see that the need for destructor functions is minimal because of Java's garbage collection subsystem.

Example

import java.io.*;
Class OpenAFile {
FileInputStream aFile = null;
OpenAFile(String filename) {
try {
aFile = new FileInputStream(filename);
} catch (java.io.FileNotFoundException e) {
System.err.println("Could not open file " + filename);
}
}
protected void finalize() throws Exception {
if (aFile != null) {
aFile.close();
aFile = null;
}
}
public static void main(String arg[]) {
OpenAFile oaf = new OpenAFile("abhishek.txt");
try {
oaf.finalize();
} catch (Exception e) {
System.out.println(e);
}
}
}

Output

Resources

Garbage Collection in .Net framework

Working of Garbage Collector: Part I
Garbage Collector Algorithm
Working With Collection Class in Java

Interfaces of collection in JAVA