Serial Garbage Collector (GC)

The Serial Garbage Collector (GC) is the simplest and oldest garbage collector in Java. It derives its name from performing all its work on a single thread.

Main Operation

Single thread to perform Garbage Collection (GC)

How does Serial GC work?

  1. Initial Mark: The algorithm identifies and marks all objects directly referenced by the application’s active threads. This marking process is performed while the application is paused briefly.
  2. Marking: The algorithm traverses the object graph starting from the marked objects and identifies all reachable objects. It marks these reachable objects as live.
  3. Remark: After the initial marking, the algorithm allows the application to resume briefly and continues marking any objects that became reachable during the pause.
  4. Sweep and Compact: Once the marking is complete, the algorithm sweeps the memory regions, deallocating memory occupied by unreferenced objects. It then compacts the memory by moving live objects together, creating a contiguous free memory space.
  5. Free Memory: After compaction, the algorithm updates the free memory space pointer to indicate the new location for object allocation.
Serial Garbage Collector (GC)

Used For:

  • Serial GC is suitable for single-threaded applications or small-scale applications with limited memory.
  • Serial GC is ideal for running on systems with a single processor and/or limited resources.


  • GC works on a Single Thread that reduces CPU overhead as there is no need to coordinate efforts between threads.
  • This is the most straightforward garbage collector in Java. It has a small footprint and requires minimal tuning.
  • Since it uses a single thread, its behaviour is predictable and easy to understand. This makes it useful for applications that require a predictable memory usage pattern.
  • Serial GC is suitable for those applications which can bear pause time and run on client-side machines.
  • It is a good choice for applications on multi-processor machines as long as the dataset remains under 100MB.


  • It freezes all other running threads of the application until garbage collection operations have concluded i.e. stop the world event happens.
  • It is not suitable for multi-threaded applications.
  • It gives poor utilization of available memory due to its small footprint.
  • Sometimes, comparatively long pause time impacts the performance of the application.


-XX: +UseSerialGC

Tuning serial GC:

  • -XX:MaxGCPauseMillis: This provides a hint to the GC that pause times should be less than the provided amount. There is no default value for this flag.
  • -XX:GCTimeRatio: This sets the ratio for the time spent between performing GC work and application work. The default value is set at 1 to 99.
  • -XX:+UseStringDeduplication: In JDK 18, String deduplication was ported from the G1 GC to Serial GC. Enabling string deduplication can reduce memory footprint by about 10% but could impact pause times.


A straightforward and effective garbage collector approach that works well in contexts with constrained memory resources or in smaller applications is the Serial Garbage Collector. Because of its simple implementation and minimal overhead, resource-constrained systems find it to be a compelling option. However, while assessing its viability for larger or memory-intensive applications, it’s crucial to take into account its constraints, like long pause durations and limited scalability. Having a thorough understanding of the features and trade-offs of the Serial GC algorithm will assist developers in selecting the best GC for their particular application needs.

You may be interested: