Java's garbage collection mechanism manages memory by automatically identifying and cleaning up objects that are no longer in use. GC is mainly operated in heap memory, divided into the new generation (including the Eden area and the Survivor area), the old age and the metaspace; common GC algorithms include mark-clear, copy and the tag-collation, which are used to solve the memory recovery problems of different generations respectively; GC triggering timings include Minor GC (Eden area full) and Major GC/Full GC (when the old age is insufficient or when System.gc() is called), explicit calls should be avoided; GC performance can be monitored and optimized through JVM parameters, logs and tools such as jstat, VisualVM, and MAT. Reasonable setting of the heap size and selecting the GC algorithm will help improve application efficiency.

Java's Garbage Collection (GC) mechanism is the core part of Java's automatic memory management. Its main task is to automatically identify and clean objects that are no longer used in the program and free up memory space. Understanding the internal working mechanism of GC will help write more efficient and stable Java programs.

Java heap memory division

The Java heap is the main operation area of ??GC and is usually divided into several areas:

• Young Generation : Most newly created objects are allocated here.
  • Eden area: Most objects will be assigned here initially.
  • Survivor area (S0 and S1): survivor objects after a GC will be moved here.
• Old Generation : Long-term surviving objects will be moved to the old generation.
• Metaspace : stores the metadata information of a class (as defined by the class), replacing PermGen in Java 8 and later.

This generational structure is designed to improve the efficiency of GC. Because most objects have a short life cycle, it is not cost-effective to scan the entire heap frequently.

Common garbage collection algorithms

GC uses different algorithms internally to identify and recycle useless objects. The following are several common algorithms:

• Mark and Sweep :

  • Marking stage: Starting from the root node, iterates through all reachable objects and marks them.
  • Clearing phase: Recycling memory occupied by unmarked objects.
  • Disadvantages: Will generate memory fragmentation.

• Copying :

  • Divide the memory into two equal parts, using only one of them at a time.
  • After the surviving object is copied to another area, the current area is completely cleared.
  • This strategy is used in the Survivor area in the new generation.
  • Advantages: No fragmentation problem; Disadvantages: Low memory utilization.

• Mark-Compact :

  • The marking phase is the same as "Tag-Clear".
  • The collation phase moves all surviving objects to one end and then cleans up memory outside the boundary.
  • This method is commonly used in the elderly to avoid memory fragmentation.

These algorithms have their own advantages and disadvantages and are used in combination in different generations to achieve optimal performance.

The timing to trigger GC

GC does not run randomly, but is triggered by the JVM under specific conditions:

• Minor GC : occurs in the Ceozoic generation, triggered when the Eden area is full. Generally, the frequency is higher and the speed is faster.
• Major GC / Full GC : occurs in the elderly, which may be triggered when the elderly are insufficient space or call System.gc() . This type of GC is usually long and will affect application performance.

It should be noted that System.gc() is recommended and the JVM may not execute immediately, but can trigger Full GC. In production environments, explicit calls should be avoided as much as possible.

In addition, some JVM parameters can also affect GC behavior, such as -XX: UseSerialGC , -XX: UseParallelGC , etc. Selecting the appropriate combination of GC algorithms is critical for performance optimization.

How to observe and tune GC performance?

In actual development, we can monitor and tune GC behavior through some tools and parameters:

• Add JVM parameters to enable GC logs:

   -Xlog:gc*:file=gc.log:time

  This allows you to see detailed GC situations in the log file.

• Use the command line tool:

  • jstat : View GC statistics in real time.
  • jvisualvm or VisualVM : Graphical interface analyzes memory usage and GC situation.
  • MAT（Memory Analyzer） : used to analyze heap dumps and troubleshoot memory leaks.

If you find that Full GC happens frequently or that a single GC takes too long, you may need to resize the heap (such as -Xms and -Xmx ), or replace the garbage collector that is more suitable for your application features.

Basically that's it. Understanding how GC works doesn't seem complicated, but it's very easy to ignore in actual development. Mastering some internal principles can help you save a lot of trouble at critical moments.

The above is the detailed content of How does Java Garbage Collection Work Internally?. For more information, please follow other related articles on the PHP Chinese website!