Java's garbage collection (GC) is a mechanism that automatically manages memory, which reduces the risk of memory leakage by reclaiming unreachable objects. 1. GC judges the accessibility of the object from the root object (such as stack variables, active threads, static fields, etc.), and unreachable objects are marked as garbage. 2. Based on the mark-clearing algorithm, mark all reachable objects and clear unmarked objects. 3. Adopt the generational collection strategy: the new generation (Eden, S0, S1) frequently executes Minor GC; the elderly performs less but takes longer time; the Metaspace stores class metadata. 4. JVM provides a variety of GC devices: Serial GC is suitable for small applications; Parallel GC improves throughput; CMS reduces pause time (Java 14 is abandoned); G1 GC is suitable for large heaps and controls pause time; ZGC and Shenandoah support super large heaps and extremely short pause time. 5. GC trigger conditions include Eden area full, promotion failure or System.gc() call (for suggestions only). 6. The finalize() method has been deprecated, and reference types such as WeakReference can finely control the object life cycle. In short, Java GC manages memory by automatically recycling objects that are no longer referenced, and developers do not need to manually release them. Understanding the GC mechanism helps optimize performance and troubleshoot problems.

Garbage collection (GC) in Java is the automatic process of reclaiming memory by destroying unused or unreachable objects. It helps developers manage memory without manually allocating and deallocating it, reducing the risk of memory leaks and dangling points.

Java's garbage collection works primarily on the heap , where all objects are stored. The JVM (Java Virtual Machine) uses a garbage collector to identify and remove objects that are no longer reachable from any live thread or static reference.

Here's how it works in practice:

1. Object Reachability and the Root Set

Garbage collection starts by determining which objects are still reachable . An object is considered reachable if it can be accessed through a chain of references starting from root objects , such as:

• Local variables in the stack frames of active threads
• Active Java threads
• Static fields
• JNI (Java Native Interface) references

If an object cannot be reached from any of these roots, it's considered garbage and eligible for collection.

2. Mark-and-Sweep Algorithm (Conceptual Basis)

Most GC algorithms are based on the mark-and-sweep approach:

• Mark phase : The GC traverses all reachable objects starting from the root set and marks them as "alive."
• Sweep phase : The GC scans the heap and reclaims memory from unmarked (ie, unreachable) objects.

This basic method avoids deleting objects that are still in use.

3. General Garbage Collection

Java's heap is divided into generations based on the object lifetime observation (most objects die young):

• Young Generation : Where new objects are created.
  • Divided into: Eden space and two Survivor spaces (S0 and S1).
  • Minor GC occurs here frequently.
• Old (Tenured) Generation : Holds long-lived objects that have survived multiple GC cycles.
  • Major GC or Full GC runs here less frequently but take longer.
• Metaspace (replaced PermGen in Java 8): Stores class metadata, not regular objects.

When an object survives several garbage collection cycles in the young generation, it gets promoted to the old generation.

4. Types of Garbage Collectors in JVM

Java provides different GC implementations optimized for various use cases:

• Serial GC : Simple, single-threaded collector. Best for small applications.
• Parallel GC (Throughput Collector) : Uses multiple threads for minor and major collections. Good for maximizing throughput.
• CMS (Concurrent Mark-Sweep) : Minimizes pause times by doing most of its work concurrently (deprecated as of Java 14).
• G1 GC (Garbage-First) : Designed for large heaps with predictable pause times. Divides heap into regions and prioritizes collection from regions with the most garbage.
• ZGC (Z Garbage Collector) : Scalable low-latency collector that can handle very large heaps (terabytes) with pause times under 10ms.
• Shenandoah : Another low-pause collector that does concurrent compaction.

5. How GC Is Triggered

Garbage collection is triggered automatically when:

• The Eden space fills up (triggers minor GC).
• Promotion from young to old generation fails due to lack of space (triggers major GC).
• Application calls System.gc() (hint only — not guaranteed to run).

Note: Calling System.gc() doesn't force GC; it only suggests that the JVM consider running it.

6. Finalization and Weak References

• Objects with finalizers ( finalize() method) may delay collection, as they are queued for finalization before being reclaimed (this method is deprecated since Java 9).
• Java also supports reference types like WeakReference , SoftReference , and PhantomReference that allows fine-grained control over object lifecycle and GC behavior.

In short, Java garbage collection automates memory management by tracking object reachability and reclaiming unused memory, using generational strategies and various GC algorithms to balance throughput, latency, and scalability. You don't need to free memory manually, but understanding GC helps write efficient code and troubleshoot performance issues.

Basically, if you stop referencing an object, the GC will eventually clean it up — when it decides it's the right time.

The above is the detailed content of How does garbage collection work in Java?. For more information, please follow other related articles on the PHP Chinese website!