GarbageCollection Rules (GarbageCollection)
Rules available in this category:
- Do_not_remove_listeners_inside_finalize
- Avoid_using_synchronized_code_within_finalizers
- Avoid_static_collections
- Always_call_reset
- Provide_protected_access_to_finalizers
- Use_array_of_long_instead_of_Dates
- Do_not_call_finalize_directly
- Always_reuse_calls_to_java_awt_Graphics_getClipBounds_method
- Avoid_calling_java_lang_Runtime_runFinalization
- Avoid_explicitly_calling_gc
- Avoid_empty_finalizers
- Always_call_super_finalize
- Always_call_super_finalize_in_finally_block
Rule 1: Do_not_remove_listeners_inside_finalize
Severity:
High
Rule:
Avoid removing listeners inside finalize method.
Reason:
Avoid removing listeners inside finalize method.
Usage Example:
package com.rule;
import java.awt.Component;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
public class Do_not_remove_listeners_inside_finalize_violation implements PropertyChangeListener
{
Component comp;
public Do_not_remove_listeners_inside_finalize_violation(Component c)
{
comp = c;
comp.addPropertyChangeListener(this);
}
protected void finalize() throws Throwable
{
comp.removePropertyChangeListener(this); // VIOLATION
super.finalize();
}
public void propertyChange(PropertyChangeEvent evt)
{
}
}
Should be written as:
Remove the listeners when they are no longer required, may be from a seperate method used for cleanup.
Reference:
http://www-106.ibm.com/developerworks/java/library/j-jtctips/j-jtc0319a.html
Rule 2: Avoid_using_synchronized_code_within_finalizers
Severity:
High
Rule:
Avoid using synchronized code within finalizers(finalize method).
Reason:
Avoid using synchronized code within finalizers(finalize method).
Usage Example:
package com.rule;
public class Avoid_using_synchronized_code_within_finalizers_violation
{
public void finalize()
{
syncMethod(); // Violation
}
public synchronized void syncMethod()
{
//...
}
}
Should be written as:
Avoid using synchronized code inside finalize method.
Reference:
http://www.cs.arizona.edu/sumatra/hallofshame/monitor-finalizer.html
Rule 3: Avoid_static_collections
Severity:
High
Rule:
Disallows the use of static collection fields.
Reason:
Disallows the use of static collection fields.
Usage Example:
public class Avoid_static_collections_violation
{
public static Vector vector = new Vector (5); // VIOLATION
public static void addToVector (Object o)
{
vector.add(o);
}
}
Should be written as:
public class Avoid_static_collections_correction
{
public Vector vector = new Vector (5); // CORRECTION
public static void addToVector (Object o)
{
vector.add(o);
}
}
Reference:
Java Performance tunning by Jack Shirazi
Rule 4: Always_call_reset
Severity:
High
Rule:
If you are using ObjectStream, do remember to call reset() method as ObjectStream classes keep a reference to all objects written or read until the `reset()' method is called and hence the objects can not be garbage collected.
Reason:
If you are using ObjectStream, do remember to call reset() method as ObjectStream classes keep a reference to all objects written or read until the `reset()' method is called and hence the objects can not be garbage collected.
Usage Example:
package com.rule;
import java.io.ObjectOutputStream;
import java.io.IOException;
class Always_call_reset_violation
{
public void writeToStream(ObjectOutputStream os, String s)throws IOException
{
os.writeObject (s);// VIOLATION
}
}
Should be written as:
package com.rule;
import java.io.ObjectOutputStream;
import java.io.IOException;
class Always_call_reset_correction
{
public void writeToStream(ObjectOutputStream os, String s)throws IOException
{
os.writeObject (s);
os.reset(); // CORRECTION
}
}
Rule 5: Provide_protected_access_to_finalizers
Severity:
High
Rule:
Provide protected access to finalize method.
Reason:
Provide protected access to finalize method.
Usage Example:
package com.rule;
public class Provide_protected_access_to_finalizers_violation
{
public void finalize() //Violation
{
}
}
Should be written as:
package com.rule;
public class Provide_protected_access_to_finalizers_corection
{
protected void finalize() //Correction
{
}
}
Reference:
Reference not available.
Rule 6: Use_array_of_long_instead_of_Dates
Severity:
High
Rule:
Avoid using array of 'Date' objects, use an array of "long" instead.
Reason:
Avoid using array of 'Date' objects, use an array of "long" instead.
Usage Example:
package com.rule;
import java.util.Date;
class Use_array_of_long_instead_of_Dates_violation
{
private final int size = 10;
private Date d[] = new Date[size]; // VIOLATION
public void method()
{
if(d != null)
{
d = null;
}
}
}
Should be written as:
package com.rule;
class Use_array_of_long_instead_of_Dates_correction
{
private final int size = 10;
private long d[] = new long[size]; // CORRECTION
public void method()
{
if(d != null)
{
d = null;
}
}
}
Reference:
Reference Not Available.
Rule 7: Do_not_call_finalize_directly
Severity:
Medium
Rule:
The finalize method is called by garbage collector and it should not be called directly
Reason:
The finalize method is called by garbage collector and it should not be called directly
Usage Example:
package com.rule;
class Do_not_call_finalize_directly_violation
{
static void method(Do_not_call_finalize_directly_violation obj) throws Throwable
{
obj.finalize();
}
protected void finalize() throws Throwable
{
super.finalize();
}
}
Should be written as:
package com.rule;
class Do_not_call_finalize_directly_violation
{
static void method(Do_not_call_finalize_directly_violation obj) throws Throwable
{
//obj.finalize();
}
protected void finalize() throws Throwable
{
super.finalize();
}
}
Reference:
http://www.ambysoft.com/javaCodingStandards.pdf
Rule 8: Always_reuse_calls_to_java_awt_Graphics_getClipBounds_method
Severity:
Medium
Rule:
The getClipBounds method always returns a new rectangle, thereby allocating more memory on every call.
Reason:
The getClipBounds method always returns a new rectangle, thereby allocating more memory on every call.
Usage Example:
import java.awt.Graphics;
public class MyClass
{
public void paint(Graphics g) // VIOLATION
{
int firstColLine = g.getClipBounds().x;
int lastColLine = g.getClipBounds().x + g.getClipBounds().width;
}
}
Should be written as:
import java.awt.Graphics;
import java.awt.Rectangle;
public class MyClass
{
public void paint(Graphics g) // VIOLATION
{
Rectangle rec = g.getClipBounds(); // CORRECTION
int firstColLine = rec.x; // CORRECTION
int lastColLine = rec.x + rec.width; // CORRECTION
}
}
Reference:
No references available.
Rule 9: Avoid_calling_java_lang_Runtime_runFinalization
Severity:
Medium
Rule:
One should not invoke garbage collection manually.
Reason:
One should not invoke garbage collection manually.
Usage Example:
public class NoRunFinalization
{
public static void main( String[] args)
{
for ( int i = 0; i < args.length; ++i )
{
System.out.println( args[ i ] );
}
Runtime.getRuntime().runFinalization();
}
}
Should be written as:
public class NoRunFinalization
{
public static void main( String[] args)
{
for ( int i = 0; i < args.length; ++i )
{
System.out.println( args[ i ] );
}
}
}
Reference:
No references available.
Rule 10: Avoid_explicitly_calling_gc
Severity:
Medium
Rule:
Avoid explicitly calling System.gc().
Reason:
Avoid explicitly calling System.gc().
Usage Example:
package com.rule;
class Avoid_explicitly_calling_gc
{
public void print()
{
Object[] oa = getObjects();
process(oa);
System.gc(); // Violation.
}
}
Should be written as:
Reference:
Reference Not Available.
Rule 11: Avoid_empty_finalizers
Severity:
High
Rule:
Avoid empty finalize method.
Reason:
Avoid empty finalize method.
Usage Example:
package com.rule;
public class Avoid_empty_finalizers_violation
{
public void finalize() // Violation
{
}
}
Should be written as:
package com.rule;
public class Avoid_empty_finalizers_correction
{
public void finalize() // Correction
{
try
{
super.finalize();
}
catch (Throwable e)
{
// ...
}
}
}
Reference:
Reference not available.
Rule 12: Always_call_super_finalize
Severity:
High
Rule:
If you are over writing finalize method then make sure that it calls super.finalize() method.
Reason:
If you are over writing finalize method then make sure that it calls super.finalize() method.
Usage Example:
package com.rule;
public class Always_call_super_finalize_violation
{
protected void finalize () throws Throwable // VIOLATION
{
//...
}
}
Should be written as:
package com.rule;
class Always_call_super_finalize_correction
{
protected void finalize () throws Throwable
{
super.finalize(); // CORRECTION
}
}
Reference:
http://www.javaworld.com/javaworld/jw-01-1999/jw-01-object_p.html
Rule 13: Always_call_super_finalize_in_finally_block
Severity:
High
Rule:
If there is a try block in the finalize method, super.finalize() should be called from the finally block.
Reason:
If there is a try block in the finalize method, super.finalize() should be called from the finally block.
Usage Example:
public class AlwaysCall_super_finalize_inFinallyBlock
{
protected void finalize () throws Throwable
{
try
{
}
catch (Exception e)
{
}
finally // VIOLATION, 'super.finalize()' is not invoked
{
return;
}
}
public class AlwaysCall_super_finalize_inFinallyBlockMember
{
protected void finalize()
{
try
{
close();
super.finalize();
} catch (Exception e)
{
//VIOLATION, missing a "finally" block that invokes 'super.finalize()'
//Note that if 'close()' throws an exception, 'super.finalize()' would not be invoked
}
}
}
Should be written as:
public class AlwaysCall_super_finalize_inFinallyBlock
{
protected void finalize () throws Throwable
{
try
{
}
catch (Exception e)
{
}
finally // VIOLATION, 'super.finalize()' is not invoked
{
super.finalize(); // CORRECTION
}
}
public class AlwaysCall_super_finalize_inFinallyBlockMember
{
protected void finalize()
{
try
{
close();
} catch (Exception e)
{
}
finally
{
super.finalize(); // CORRECTION
}
}
}
Reference:
"The Java Programming Language, Second Edition", by Ken Arnold and James Gosling. Page 49.