There are 7 of the collectors above, divided into two pieces, the above is the new generation collector, and the following is the older collector. If there is a connection between two collectors, they can be used together.
The Serial collector is a new generation collector , single-threaded execution, using a copy algorithm. It must suspend all other worker threads (user threads) while performing garbage collection. It is the default new generation collector in Jvm client mode. For an environment limited to a single CPU, the Serial collector has no thread interaction overhead, so it can naturally achieve the highest single-thread collection efficiency by focusing on garbage collection.
ParNew collector is actually serial collection A multi-threaded version of the collector that behaves the same as the Serial collector except that it uses multiple threads for garbage collection.
Parallel Scavenge collector too A new generation collector, which is also a collector using a copy algorithm and a parallel multi-threaded collector. The characteristic of the parallel Scavenge collector is that its focus is different from other collectors. The focus of collectors such as CMS is to shorten the pause time of the user thread during garbage collection as much as possible, while the goal of the parallel Scavenge collector is to achieve a feasible Controlled throughput. Throughput = program running time/(program running time + garbage collection time), the virtual machine ran for a total of 100 minutes. Among them, garbage collection takes 1 minute, and the throughput is 99%.
Serial Old is the old generation version of the Serial collector. It also uses a single thread to perform collection and uses the "mark-sort" algorithm. Mainly used in virtual machines in Client mode.
Parallel Old is the old generation version of the Parallel Scavenge collector, using multi-threading and the "mark-sort" algorithm.
##CMS (Concurrent GC) Collector
CMS (Concurrent Mark Sweep) collector is a method to obtain the shortest collection The pause time is the target collector. The CMS collector is implemented based on the "mark-clear" algorithm. The entire collection process is roughly divided into 4 steps:
①.Initial mark (CMS initial mark)
##②.Concurrent mark (CMS concurrenr mark)
③.Remark (CMS remark)
④.Concurrent sweep (CMS concurrent sweep)
The two steps of initial marking and re-marking still require pausing other user threads. The initial marking only marks objects that GC ROOTS can directly associate with, which is very fast. The concurrent marking stage is the stage of GC ROOTS root search algorithm, which will determine whether the object is alive. The re-marking phase is to correct the marking records of that part of the objects that have changed due to the continued running of the user program during the concurrent marking period. The pause time in this phase will be slightly longer than the initial marking phase, but shorter than the concurrent marking phase. .
Due to the longest time-consuming concurrent marking and concurrent clearing processes in the entire process, the collector thread can work together with the user thread, so overall, the memory of the CMS collector The recycling process is executed concurrently with the user thread.
Advantages of the CMS collector: concurrent collection, low pauses, but CMS is far from perfect. The collector mainly has three significant shortcomings:
CMS collector is very sensitive to CPU resources. . In the concurrent phase, although it will not cause the user thread to pause, it will occupy CPU resources and cause the reference program to slow down and the total throughput to decrease. The number of recycling threads started by CMS by default is: (number of CPUs + 3) / 4.
CMS collector cannot handle floating garbage, and "Concurrent Mode Failure" may occur, which may lead to another Full GC after failure. Since the user thread is still running during the concurrent cleanup phase of CMS, new garbage will continue to be generated as the program runs and heats up. This part of garbage appears after the marking process. CMS cannot process it in this collection and has to wait for the next GC. Clean it up. This part of garbage is called "floating garbage". It is also because the user thread still needs to run during the garbage collection phase,
that is, sufficient memory space needs to be reserved for the user thread to use, so the CMS collector cannot wait until the old generation is almost completely filled like other collectors before collecting. , a portion of memory space needs to be reserved for program operation during concurrent collection. Under default settings, the CMS collector will be activated when 68% of the space in the old generation is used. You can also provide a trigger percentage through the value of the parameter -XX:CMSInitiatingOccupancyFraction to reduce the number of memory recycling times and improve performance. If the memory reserved during CMS operation cannot meet the needs of other threads of the program, a "Concurrent Mode Failure" failure will occur. At this time, the virtual machine will start a backup plan: temporarily enable the Serial Old collector to re-collect garbage in the old generation, so that The pause is very long. Therefore, setting the parameter -XX:CMSInitiatingOccupancyFraction too high will easily lead to "Concurrent Mode Failure" failure and reduce performance.The last disadvantage is that CMS is a collector based on the "mark-clear" algorithm. After collecting using the "mark-clear" algorithm, a large amount of fragments will be generated. When there are too many space fragments, it will bring a lot of trouble to object allocation. For example, for large objects, the memory space cannot find contiguous space to allocate and has to trigger a Full GC in advance. In order to solve this problem, the CMS collector provides a -XX:UseCMSCompactAtFullCollection switch parameter, which is used to add a defragmentation process after Full GC. You can also use the -XX:CMSFullGCBeforeCompaction parameter to set how many times to perform uncompressed Full GC, followed by Do a defragmentation process.
The G1 (Garbage First) collector is a new collector provided by JDK1.7. The G1 collector is based on the "mark-complement" algorithm, which means that it will not generate memory fragmentation. Another feature is that the previous collectors collected the entire new generation or the old generation, while G1 collected the entire Java heap (including the new generation and the old generation).
-XX:+
##-XX:-
-XX:
##-XX:
| Parameter Description | ||
|---|---|---|
| -XX:+ UseSerialGC |
The default value for Jvm to run in Client mode. After turning on this switch, the collector combination of Serial + Serial Old is used for memory recycling | |
| -XX:+UseParNewGC | After turning on this switch, use the ParNew + Serial Old collector for garbage collection | |
| -XX:+UseConcMarkSweepGC | Use ParNew + CMS + Serial Old collector combination for memory recycling, Serial Old appears as CMS "Concurrent The fallback collector is used after Mode Failure" failure. | |
| ##-XX:+UseParallelGC | The default value for Jvm to run in Server mode. After turning on this switch, use Parallel Scavenge + Serial Old collector combination for recycling |
|
| ##-XX:+UseParallelOldGC | Use Parallel Scavenge + Parallel Old collector combination for recycling | |
| -XX:SurvivorRatio | The capacity ratio of the Eden area to the Survivor area in the new generation, the default is 8, which means Eden:Subrvivor = 8:1 | |
| ##-XX:PretenureSizeThreshold | is directly promoted to the size of the old generation object. After setting this parameter, objects larger than this parameter will be directly Old generation allocation | |
| -XX:MaxTenuringThreshold | Promotes to the age of objects in the old generation, after each Minor GC , the age is increased by 1, and when it exceeds the value of this parameter, it enters the old generation | |
| ##-XX:UseAdaptiveSizePolicy | Dynamicly adjust the size of each area in the java heap and the age of entering the old generation||
| -XX :+HandlePromotionFailure | Whether thenew generation collection guarantee is allowed, after a minor gc is performed, when another block of Survivor space is insufficient, Will be retained directly in the old generation | |
| #-XX:ParallelGCThreadsSet the number of threads for parallel GC for memory recycling | ||
| XX:GCTimeRatioThe ratio of GC time to the total time. The default value is 99, which means 1 is allowed. % of GC time, only valid when using the | Parallel Scavenge collector||
| XX:MaxGCPauseMillis Set the maximum pause time of GC, valid under | Parallel Scavenge collector||
| Set the CMS collector to start garbage collection after the old generation space is used. The default value is 68%, only in Valid when using CMS collector, -XX:CMSInitiatingOccupancyFraction=70 | ||
| XX:+UseCMSCompactAtFullCollection Since the CMS collector will generate fragments, this parameter sets whether a memory defragmentation process is required after the garbage collector. It is only valid when the CMS collector is used. |
-XX:+CMSFullGCBeforeCompaction | |
|
Set the CMS collector to perform a memory defragmentation process after several garbage collections. Typically used with the UseCMSCompactAtFullCollection parameter |
##-XX:+UseFastAccessorMethods | |
| Primitive type optimization |
-XX:+DisableExplicitGC | |
| Whether to turn off manual System.gc |
-XX:+CMSParallelRemarkEnabled | |
| Reduce mark pause |
-XX:LargePageSizeInBytes | The size of the memory page cannot be set too large, which will affect the size of Perm, -XX:LargePageSizeInBytes=128m |
Client and Server mode default GC
| ##New generation GC method | Old generation and persistentGeneration GC method | |
|---|---|---|
| Client | Serial Serial GC | Serial Old Serial GC |
| Parallel Scavenge Parallel recycling GC | Parallel Old Parallel GC |
| ##New generation GC method | Old generation and persistenceGeneration GC method | |
|---|---|---|
-XX:+UseSerialGC |
Serial Serial GC | Serial Old Serial GC |
| -XX:+UseParallelGC | Parallel Scavenge Parallel recycling GC | Serial Old Parallel GC |
| ParNew Parallel GCCMS Concurrent GC | When "Concurrent Mode Failure" appears Use Serial Old Serial GC |
|
| ParNew | Parallel GCSerial Old | Serial GC |
| UseParallelOldGC Parallel Scavenge Parallel GC | Parallel Old Parallel GC | |
| #-XX:+UseConcMarkSweepGC-XX:+UseParNewGC ##Serial Serial GC |
##CMS Concurrent GC When "Concurrent Mode Failure appears "When | uses Serial OldSerial GC ## The above is the content of Java virtual machine learning - garbage collector. For more related content, please pay attention to the PHP Chinese website (www.php.cn) ! |
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
