The serial collector is performed via a single thread on a single CPU. When this GC thread is run, the execution of the application will pause until the collection is complete.

This collection is best used when your application has a small data set up to approximately 100 MB and does not have a requirement for low pause times.

The parallel collector, also known as the throughput collector, can be performed with multiple threads across several CPUs. Using these multiple threads significantly speeds up GC.

This collector is best used when there are no pause time constraints and application performance is the most important aspect of your program.

The parallel compacting collector is similar to the parallel collector except for refined algorithms that reduce collection pause times.

This collector is best used for applications that do have pause time constraints.

The CMS, also known as the low-latency collector, implements algorithms to handle large collections that may warrant long pauses.

This collector is best used when response times take precedence over throughput times and GC pauses.

The Garbage-First collector, also known as the G1 collector, is used for multiprocessor machines with large memories. This server-style GC meets pause time goals with high probability, while achieving high throughput. Whole-heap operations (e.g., global marking) are performed concurrently with the application threads preventing interruptions proportional to the heap or live-data size.

The garbage collector can be explicitly requested to be invoked with System.gc() or Runtime.getRuntime().gc(). However, explicit invocation of the GC should generally be avoided because it could force full collections (when a minor collection may suffice), thereby unnecessarily increasing the pause times. The request for System.gc() is not always fulfilled as the JVM can and does ignore it at times.

Every object has a finalize() method inherited from class Object. The garbage collector, prior to destroying the object, can invoke this method, but this invocation is not guaranteed. The default implementation of the finalize() method does nothing and although it is not recommended, the method can be overridden:

public class TempClass extends SuperClass {
  ...
  // Performed when Garbage Collection occurs
  protected void finalize() throws Throwable {
    try {
      /* Desired functionality goes here */
    } finally {
      // Optionally, you can call the
      // finalize method of the superclass
      super.finalize(); // From SuperClass
    }
  }
}

The following example destroys an object:

public class MainClass {
  public static void main(String[] args) {
    TempClass t = new TempClass();
    // Object has references removed
    t = null;
    // GC made available
    System.gc();
  }
}