Serial Garbage Collector (GC)

by

Serial Garbage Collector or Serial GC is the most basic garbage collection (GC) algorithm used in Java. It works in a single-threaded way, meaning it uses one thread to perform all garbage collection tasks. During a GC event, your application pauses completely—this is called a stop-the-world pause.

Although Serial GC causes these pauses, it’s still very efficient for small applications or systems with limited resources like memory and CPU. Because of its simplicity, it’s also easier to tune and understand compared to other GC types.

How Serial GC works (Step by Step)?

  1. Initial Mark: It begins with a short pause where it marks objects that are directly reachable from the root, such as static variables or active threads.
  2. Mark Phase: Then, it continues to follow references and marks all reachable objects.
  3. Remark: Before cleanup, it does a quick second pause to mark any new objects that appeared during the mark phase.
  4. Sweep and Compact: After marking, it deletes unreachable (dead) objects and moves the remaining ones together to avoid memory gaps.
  5. Pointer Reset: Finally, it resets the pointer so that new objects can be placed in a single, contiguous block of memory.
Serial Garbage Collector (GC)

When to use Serial GC?

You should consider Serial GC if:

  • Your application is small and single-threaded
  • You’re running on a system with one CPU core
  • Low memory usage is a priority
  • GC simplicity is more important than performance
  • Occasional longer pauses are acceptable

It is ideal for command-line tools, test environments, embedded devices, or simple GUI applications.

How to enable Serial GC?

To enable it in Java, add the following JVM option:

-XX: +UseSerialGC

Tuning Options for Serial GC

Here are some useful flags you can use:

  • -XX:MaxGCPauseMillis=<n>
    Suggests a maximum pause time goal in milliseconds. The JVM tries to respect this but doesn’t guarantee it.
  • -XX:GCTimeRatio=<n>
    Controls the balance between time spent collecting garbage and time spent running your app. For example, 99 means 1% of time can be used for GC.
  • -XX:+UseStringDeduplication (JDK 8+)
    Helps save memory by removing duplicate strings in memory, though it may increase GC pause time slightly.

Pros of Serial GC

  • Simple to configure and understand
  • Low memory and CPU overhead
  • Works well in resource-constrained environments
  • Predictable behavior, which is great for debugging

Limitations of Serial GC

  • Not suitable for large heaps or multi-threaded applications
  • Causes long stop-the-world pauses
  • Can lead to poor performance in high-throughput systems
  • Doesn’t scale with multiple CPUs

Conclusion

To sum up, Serial GC is a great choice when:

  • Your app is small and simple
  • You’re okay with occasional longer GC pauses
  • You’re running on low-end hardware
  • You want an easy-to-understand GC with no surprises

However, if your application is large or performance-critical, you should explore other GC types like G1 or Parallel GC.

You may be interested: