Garbage collection (GC) is an automatic memory management process handled by the Java Virtual Machine (JVM). Its primary purpose is to identify and discard objects no longer used by the program, thereby freeing up and reusing resources. Java programmers do not need to explicitly release the memory occupied by objects, which reduces issues such as memory leaks and pointer errors.
Basic Principles of Garbage Collection:
- Marking - The JVM first marks all objects reachable from the root set (such as thread stacks and global references) using a root search algorithm.
- Sweeping - Then, the garbage collector sweeps away all unmarked objects, as these objects are no longer referenced by any active thread or reference.
Main Garbage Collection Algorithms:
-
Mark-Sweep: This is the most basic form, where all active objects are marked first, and then all unmarked objects are swept away. Its drawback is that it may leave significant memory fragmentation after the sweep.
-
Copying: Memory is divided into two halves, with only one half used at a time. During garbage collection, active objects are copied from the current half to the other half, and the original half is then cleared. This reduces fragmentation but sacrifices half of the memory.
-
Mark-Compact: An improvement over Mark-Sweep, it marks objects as in Mark-Sweep, but during the sweep phase, it moves all live objects to contiguous memory locations, reducing fragmentation.
-
Generational Collection: This is the most common method used in modern JVMs. Memory is divided into several generations, typically including the Young Generation, Old Generation, and PermGen (before Java 8) or Metaspace (from Java 8 onwards). Objects are allocated to different generations based on their survival time; most objects are created in the Young Generation and die quickly, enabling more efficient garbage collection.
Examples of Garbage Collectors:
-
Serial GC: A single-threaded garbage collector that is simple but inefficient, suitable for small applications.
-
Parallel GC: A multi-threaded garbage collector suitable for multi-core servers, which enhances garbage collection speed.
-
Concurrent Mark Sweep (CMS): Executes most garbage collection work concurrently, reducing application pause times, suitable for interactive applications.
-
G1 (Garbage First): A region-based garbage collector designed to handle large memory with predictable pause times, suitable for large enterprise applications.
Practical Example:
Suppose we have a Java application where many temporary objects are created as part of data structures. As these temporary objects are no longer needed, the JVM's garbage collector automatically identifies objects no longer referenced and recovers the memory they occupy in the next garbage collection cycle. This allows Java applications to continue running efficiently within limited memory resources without programmers manually managing memory.
Through garbage collection, Java provides a relatively safe and efficient way to manage memory, enabling Java applications to run stably in various environments while reducing the risk of memory leaks.