JVM foundation ＞ CMS garbage collector

CMS The collector

CMS Full name Concurrent Mark Sweep, It's a concurrent 、 The main use of markers - The garbage collector of the clearing algorithm , The recycler is designed for the elderly generation , During the initialization phase, it will result in STW.

• Here's one a key : The main mark - The garbage collector of the clearing algorithm
  It's not a marker - Sorting algorithm -> It means that there will be many memory gaps , Memory fragmentation , There are solutions

  • If there is not enough memory during concurrency, new objects will be generated , Will fail concurrently , Virtual Opportunities are forced to be temporarily enabled Single threaded serial old Garbage collector To recycle the old garbage
  • There is also a parameter configuration , many times FullGC after , The next time FullGC I will execute a paragraph first Mark - Sorting algorithm

• No longer recommended CMS The collector The biggest reason is : There is G1 The collector , Improved some of its shortcomings , The authorities marked him as not recommended

  • In fact, it might CMS Or the most used , Everyone is JDK 8

CMS describe

• CMS The collector says A new generation of ParNew The collector and Old age CMS The collector The combination of
• Whether it's ParNew Collectors are still obsolete Serial and Parallel The collector of , There is a very serious problem
  • Is in the ParNew When these collector threads start running , other All threads are suspended , until GC Thread completed
  • These collector threads cannot even coexist with other threads , With you and without me
• and CMS It is still used in the new generation ParNew The collector , Used in older generations new CMS The collector , It can run concurrently with other threads
  • This is not to say that there will be no STW Other threads will not be paused , Not at all
  • Is in Pause for a short time when you need to , Other times threads can coexist , This will lead to visible improvement
• So far , No garbage collector can prevent STW The birth of , Can only lower STW To optimize garbage collection efficiency
• for the first time Realized to let garbage collection thread and user thread （ Basically ） Work at the same time

CMS Application scenarios

• Appear in the : Everything gets stuck and you break down Applications for !!!

  • APP It's just a light You don't know what happened for no reason It got stuck
  • Impact on user experience

• Relative , May not be used CMS Application scenarios of

  • You know that there is a pause in submitting things, a pause in uploading, and so on
  • In theory, you'll get stuck , Slightly stuck , It doesn't affect the user experience much

CMS To configure

Heap memory for 4G, The new generation is 2G, The old generation is also 2G

The new generation adopts ParNew The collector , The old days used concurrent mark removal CMS The collector

When the memory occupancy rate of the old age reaches 80% It's going to be FullGC, And enable defragmentation

-Xms4g -Xmx4g -Xmn2g -Xss1024K 
-XX:ParallelGCThreads=5 
-XX:+UseConcMarkSweepGC -XX:+UseParNewGC 
-XX:+UseCMSCompactAtFullCollection 
-XX:CMSInitiatingOccupancyFraction=80

CMS Collection process

Be careful : The process of this description is CMS The collection process in the old days .CMS It was originally a garbage collector in the old days

1. Initial marker (CMS-initial-mark) , It can lead to STW;
   1. Mark GC Roots Accessible objects ,GC Roots Itself and objects that can be directly referenced -> The markers are all objects from the old age
   2. The content is not much , Fast ,STW Pause the actual segment
2. Concurrent Tags (CMS-concurrent-mark), Run with user thread ;
   1. From just marking GC Roots The reachable object starts , Traverse all reachable objects
   2. It takes a long time , But this phase can run concurrently
3. Re label (CMS-remark) , It can lead to swt;
   1. Verify the modification tag , Marks that are not marked to
      1. The reference chain has changed and the tag is reanalyzed
   2. The time is average , Faster than initial marking , Slower than concurrent markup
4. Concurrent elimination (CMS-concurrent-sweep), Run with user thread ;
   1. Delete directly

CMS The shortcomings of

1. Use Mark - The removal algorithm has fragments , But there are solutions , There are corresponding parameters to start sorting

2. Floating garbage : The last concurrent cleanup phase , There will also be new objects coming to the old age , These object garbage can no longer be marked at this time , Can only wait until next time

3. Affect the overall performance of the program : Because garbage collection is performed concurrently , therefore cpu Will always allocate time to the garbage collection thread , Will always occupy a part of cpu Resources for

give the thumbs-up . handsome young man