AppPerfect

GarbageCollection Rules (GarbageCollection)

Rules available in this category:

  1. Do_not_remove_listeners_inside_finalize
  2. Avoid_using_synchronized_code_within_finalizers
  3. Avoid_static_collections
  4. Always_call_reset
  5. Provide_protected_access_to_finalizers
  6. Use_array_of_long_instead_of_Dates
  7. Do_not_call_finalize_directly
  8. Always_reuse_calls_to_java_awt_Graphics_getClipBounds_method
  9. Avoid_calling_java_lang_Runtime_runFinalization
  10. Avoid_explicitly_calling_gc
  11. Avoid_empty_finalizers
  12. Always_call_super_finalize
  13. 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
}
}

Reference:  http://developer.java.sun.com/servlet/PrintPageServlet?url=http%3A//developer.java.sun.com/developer/technicalArticles/ALT/sockets/

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.