Java VM garbage collector: Features Application Scenario Setting Parameters Basic operating principles

Main Features Application Scenario Setting Parameters Basic operating principles

\

How to determine whether an object is alive or dead from Java Virtual Machine Garbage Collection (I) Basics? Learn about several common algorithms for Java VIRTUAL Machine garbage collection in Java Virtual Machine Garbage Collection (2) Garbage Collection Algorithms.

Let’s take a look at the seven garbage collectors in the HotSpot VIRTUAL machine: The Serial, ParNew, Parallel Scavenge, Serial Old, Parallel Old, CMS, AND G1 garbage collection concepts are introduced, as well as their characteristics, application scenarios, setup parameters, and operating principles.

1. Overview of garbage collector

The garbage collector is an implementation of the garbage collection algorithms (mark-sweep, copy, mark-collation, train). The garbage collector may vary from vendor to vendor and JVM version, but this article focuses on the garbage collector in the HotSpot VIRTUAL machine.

1-1. Garbage collector combination

1-2. The difference between concurrent and parallel garbage collection

(A) Parallel

Refers to multiple garbage collection threads working in parallel while the user thread is still in a waiting state.

Be the ParNew, Parallel Avenge, Parallel Old;

(B) Concurrent

Refers to the simultaneous execution of the user thread and the garbage collection thread (but not necessarily in parallel and may be executed alternately);

The user program continues to run while the garbage collector thread runs on another CPU.

Such as CMS, G1 (also parallel);

1-3. The difference between Minor and Full GC

2. Serial collector

The Serial garbage collector is the most basic and oldest;

JDK1.3.1 was the only choice for HotSpot new generation collection before;

1, the characteristics of

For the New generation;

Copy algorithm is adopted;

Single-thread collection;

When garbage collection is done, all worker threads must be paused until complete;

“Stop The World”;

The Serial/Serial Old collector runs as follows:

2. Application scenarios

It is still the default new generation collector for HotSpot in Client mode.

There are also advantages over other collectors:

Simple and efficient (compared to the single-threaded of other collectors);

For environments limited to a single CPU, the Serial collector achieves the highest single-thread collection efficiency without thread interaction (switching) overhead;

In a user’s desktop application scenario, the available memory is generally small (tens of megabytes to one or two hundred megabytes) and garbage collection can be completed in a relatively short time (tens of MS to more than one hundred MS), as long as it does not occur frequently, this is acceptable

3. Set parameters

“-xx :+UseSerialGC” : add this parameter to explicitly use the serial garbage collector;

4. Stop TheWorld

JVM in the background automatically initiated and automatically completed, invisible to the user, the user’s normal work thread all stopped, that is, GC pause;

Will bring users bad experience;

From JDK1.3 to the present, from Serial collector – Parallel collector – CMS- G1, user thread pause times have been reduced, but still cannot be completely eliminated;

For more information about “Stop The World”, see “Java Virtual Machine Garbage Collection (1) Basics”, “2-2, Reachability Analysis Algorithm “.

For more information about the Serial collector:

The Memory Management in the Java HotSpot ™ Virtual Machine “section 4.3 Serial Collector (Memory Management), the white paper: www.oracle.com/technetwork…

The Java Platform, Standard Edition HotSpot Virtual Machine Garbage Collection Tuning Guide, Section 5, Available Collectors Docs.oracle.com/javase/8/do…

ParNew collector

4. Parallel avenge

The Parallel Collector is also known as a Throughput Collector because of its affinity to the Throughput.

1, the characteristics of

(A) The ParNew collector has some characteristics similar to those of the ParNew collector

Cenozoic collector;

Copy algorithm is adopted;

Multithreaded collection;

(B) The main feature is that its focus is different from other collectors

Collectors such as CMS focus on minimizing the pause time of user threads during garbage collection;

The goal of the Parallel Insane is to achieve a controlled Throughput.

Details on throughput and collector concerns are provided later in this section;

2. Application scenarios

The goal of high throughput is to reduce garbage collection time and allow user code to run longer;

When the application runs on multiple cpus and does not have a particularly high pause time requirement, that is, the program mainly performs calculations in the background without much interaction with the user;

For example, applications that perform batch processing, order processing, payroll, scientific calculations;

3. Set parameters

The Parallel Avenge collector provides two parameters for precise throughput control:

(A), “-xx :MaxGCPauseMillis”

Controls the maximum garbage collection pause time, the number of milliseconds greater than 0;

If MaxGCPauseMillis is set to a smaller size, pause times may decrease, but throughput may also decrease.

Because garbage collection may occur more frequently;

(B), “-xx :GCTimeRatio”

Set the ratio of garbage collection time to total time, 0<n<100 integer;

GCTimeRatio is equivalent to setting the throughput size.

The ratio of garbage collection execution time to application execution time is calculated as follows:

      1 / (1 + n)

For example, the -xx :GCTimeRatio=19 option sets the garbage collection time to 5% of the total time –1/(1+19);

The default is 1%–1/(1+99), which is n=99;

The time spent in garbage collection is the total time collected by the younger generation and the older generation;

If the throughput goal is not met, the memory size of the generation is increased to maximize the time the user program runs;

In addition, there is another parameter worth watching:

(C), “-xx :+UseAdptiveSizePolicy”

With this parameter enabled, there is no need to manually specify details such as:

The size of the Cenozoic (- Xmn), Eden and Survivor area ratio (- XX: SurvivorRation), promotion of the old s objects age (- XX: PretenureSizeThreshold);

The JVM collects performance monitoring information based on current system health and adjusts these parameters dynamically to provide the most appropriate pause times or maximum throughput, a method known as GGC adaptive tuning.

Here’s a recommended approach:

(1), just set the size of memory data (such as “-xmx” to set the maximum heap);

(2) Then use “-xx :MaxGCPauseMillis” or” -xx :GCTimeRatio” to set an optimization target for the JVM;

(3) The tuning of those detailed parameters is done by the JVM adaptively;

This is an important difference between the Parallel Scavenge collector and the ParNew collector.

For more information on target tuning and GC adaptive tuning strategies, see:

Memory Management in the Java HotSpot™ Virtual Machine Automatic Selections and Behavior Tuning www.oracle.com/technetwork…

Java Platform, Standard Edition HotSpot Virtual Machine Garbage Collection Tuning Guide Docs.oracle.com/javase/8/do…

Description of throughput and collector concerns

(A) Throughput

The ratio of CPU time spent running user code to total CPU consumption;

Throughput = run user code time/(run user code time + garbage collection time);

High throughput means less garbage collection time and longer runtime for user code;

(B) Desired target of garbage collector (concerns)

(1) Pause time

Shorter pauses are suitable for applications that need to interact with the user;

Good response speed can improve user experience;

(2) Throughput

High throughput can efficiently use THE CPU time to complete the computation task as soon as possible;

Mainly suitable for tasks that do not require much interaction in the background;

(3) Footprint

Minimize the memory space of the heap while achieving the first two goals;

Better spatial locality can be obtained;

To find out more about the Parallel Avenge collector:

The official garbage collection tuning guidelines Section 6: docs.oracle.com/javase/8/do…

All of the above are Cenozoic collectors, and we’ll start with the old-age collectors;

Serial Old collector

Serial Old is an older version of the Serial collector;

1, the characteristics of

For the old age;

A “mark-sweep-compact” algorithm (and compression, mark-sweep-compact);

Single-thread collection;

The Serial/Serial Old collector runs as follows:

2. Application scenarios

It is mainly used in Client mode.

In Server mode there are two main uses:

To be used with the Parallel Collector insane or preexisting in JDK1.5.

(B) as a backup plan for CMS collector, used in the event of Concurrent Mode Failure in Concurrent collection (detailed below);

For more information about the Serial Old collector:

White paper on memory management section 4.3.2: www.oracle.com/technetwork…

Parallel Old collector

7. CMS collector

A Concurrent Mark Sweep (CMS) Collector is also called a Concurrent Low Pause Collector or low-latency garbage Collector;

The ParNew collector was briefly introduced earlier;

1, the characteristics of

For the old age;

Based on the “mark-clean” algorithm (no compression operation, memory fragmentation);

To obtain the shortest recovery pause time as the goal;

Concurrent collection, low pause;

Requires more memory (see disadvantages below);

            

HotSpot is the first truly Concurrent collector in JDK1.5.

For the first time, garbage collection threads work (basically) at the same time as user threads;

2. Application scenarios

Scenarios with a lot of user interaction;

Expect the system to stop the shortest time, pay attention to service response speed;

To give users a better experience;

Such as common WEB, B/S system on the server application;

3. Set parameters

“-xx :+UseConcMarkSweepGC” : specifies to use the CMS collector;

4, CMS collector operation process

It is more complex than the previous collectors and can be divided into four steps:

(A) CMS Initial Mark

Mark only objects to which GC Roots can be directly associated;

Very fast;

But you need to “Stop The World”;

(B) CMS Concurrent Mark

GC Roots Tracing process;

The surviving object is marked in the collection just generated;

The application is also running;

There is no guarantee that all live objects will be marked;

(C) re-marking (CMS remark)

To correct the mark record of that part of the object whose mark changes because the user program continues to operate during concurrent marking;

You need to “Stop The World”, and The pause is slightly longer than The initial tag, but much shorter than The concurrent tag;

Using multi-thread parallel execution to improve efficiency;

(D) CMS Concurrent sweep

Recycle all garbage objects;

The concurrent markers and concurrent sweeps that take the most time throughout the process work with the user thread;

So in general, the CMS collector’s memory reclamation process is executed concurrently with the user thread;

The CMS collector runs as follows:

5. The CMS collector has three obvious disadvantages

(A) Very sensitive to CPU resources

Concurrent collection does not suspend user threads, but it can slow down the application and reduce overall throughput because it consumes CPU resources.

CMS default number of collection threads =(number of cpus +3)/4;

When the number of cpus is more than 4, the collection threads occupy more than 25% of the CPU resources, which may have a great impact on user programs. Less than four, the impact is greater and may be unacceptable.

\

Incremental concurrent collector:

For this situation, “Incremental Concurrent Mark Sweep” (I-CMS) occurred;

Similar to the idea of using preemption to simulate multitasking mechanism, let the collection thread and user thread run alternately, reduce the running time of the collection thread;

But the effect is not ideal, JDK1.6 after the official no longer advocate users.

For more information:

The official garbage collection tuning guide section 8.8 Incremental Mode:docs.oracle.com/javase/8/do…

See some descriptions in section 4.6.3 of the Memory Management Whitepaper;

(B) Floating garbage cannot be processed and a “Concurrent Mode Failure” may occur

(1) Floating Garbage

In concurrent removal, the user thread generated new garbage, known as floating garbage;

This makes it necessary to reserve a certain amount of memory space for concurrent cleanup, unlike other collectors, which can almost fill up the old years and then collect;

It is also possible to assume that the CMS needs more space than other garbage collectors;

“- XX: CMSInitiatingOccupancyFraction” : setting the CMS reserved memory space;

JDK1.5 defaults to 68%;

JDK1.6 becomes about 92%;

(2) “Concurrent Mode Failure

A “Concurrent Mode Failure” occurs if the CMS does not have enough memory reserved for the program.

At this point, the JVM enables backup: temporarily enable the Serail Old collector, resulting in another Full GC;

This price is very big, so CMSInitiatingOccupancyFraction can’t set too high.

(C) A large number of memory fragments are generated

Because CMS is based on “mark-clear” algorithm, no compression operation is performed after clearing.

Java Virtual Machine garbage Collection (2) Garbage collection algorithm “mark-clean” algorithm introduction has said:

Generating a large number of discrete memory fragments can cause large memory objects to be allocated without finding enough contiguous memory, requiring another Full GC action to be triggered in advance.

Solutions:

(1), “- XX: + UseCMSCompactAtFullCollection”

Make the CMS not perform Full GC when the above situation occurs, and open the merge defragmentation process;

However, the merge and collation process cannot be concurrent and the pause time will be longer.

The default open (but not, in combination with the following CMSFullGCsBeforeCompaction);

(2), “- XX: + CMSFullGCsBeforeCompaction”

Set the number of uncompressed Full GC’s to perform a collation;

To reduce the pause time in the consolidation process;

The default is 0, which means that Full GC is performed every time and no collation is done;

Since space is no longer contiguous, CMS needs to use the available “free list” memory allocation method, which is more expensive than the simple practical “collision pointer” memory allocation.

For more information about how to allocate memory, see Java Object Creation in a Java Virtual Machine.

Overall, CMS reduces the application pause time when performing old-era garbage collection compared to the Parallel Old garbage collector;

However, it increases the application pause time for new generation garbage collection, reduces throughput, and takes up more heap space.

For more information about the CMS collector, see:

Section 8 of the garbage collection tuning guide Concurrent Mark Sweep (CMS) Collector:docs.oracle.com/javase/8/do…

The white paper on memory management section 4.6 Concurrent Mark – Sweep (CMS) Collector:www.oracle.com/technetwork…

G1 collector