JVM memory management------Introduction to garbage collector

We have discussed various GC algorithms in the previous chapter, so what is a garbage collector?
In layman's terms, using a programming language to implement an algorithm, the resulting program is a garbage collector. Now that we have talked about the implementation of programming languages, when discussing garbage collectors, we have already involved specific virtual machine implementations.
Perhaps many JAVA developers don’t know that in the JDK we usually use, the default JVM is hotspot. In other words, the JVM we use most of the time is the implementation version of hotspot. Therefore, The garbage collector discussed in LZ this time is all based on the hotspot version of JVM. Please be aware of this.
More intuitively, we can enter java -version to check the JVM version on the machine we usually develop. I believe most ape friends are familiar with this command. The screenshot of LZ’s machine is as follows.

Classification of garbage collectors

We have mentioned above that the garbage collector is actually the programming language implementation of the algorithm. Since programming languages ​​are involved, threads must be inseparable, and when we explained the algorithm earlier, we always assumed that a GC thread was doing GC work.
Therefore, garbage collectors are roughly divided into the following three categories.
Serial collector: It has only one GC thread, and as mentioned before, it needs to pause the user program (stop the world) when running.
Parallel collector: It has multiple GC threads, and it also needs to pause the user program (stop the world).
Concurrent collector: It has one or more GC threads, and it needs to suspend the user program (stop the world) in some stages, and execute part of the stage concurrently with the user program.

Concurrency and Parallel

After reading the above definition, I believe some friends have been confused. Sometimes it is single-threaded, sometimes it is multi-threaded, and sometimes it is serial. , sometimes parallel, sometimes concurrent, is this all nonsense?
There is no need to say more about single-threading and multi-threading. This is easy to understand. Serial and parallel are also easy to understand. What is difficult to distinguish is parallel (parallel) and concurrent (concurrent).
For many explanations about concurrency, LZ thinks there is one that is most appropriate. It is explained this way, concurrency means that two tasks A and B need to run independently of each other, and after task A starts first, task B starts before task A ends.
Concurrency itself is relatively easy to understand, so what is its relationship and difference with parallelism?
In fact, parallelism is an implementation method of concurrency. LZ thinks you may understand it better by saying this. Of course, parallelism is not the only way to achieve concurrency. Another way is the time slice switching that we are familiar with. That is, task A is executed for a while, task B is executed for a while, and executed alternately.
Parallelism can only occur under the premise of multi-core multi-processor or distributed system (essentially still multi-core multi-processor), while alternate execution or time slice switching occurs on a single-core processor.

Garbage collector in hotspot

We have briefly discussed the classification of garbage collectors above. In hotspotJVM, each type of garbage collector has a corresponding implementation, as follows.
Implementation of serial collector: serial (used for the new generation, using the copy algorithm), serial old (used for the old generation, using the marking/collation algorithm)
Implementation of the parallel collector: ParNew (used for New generation, using replication algorithm), Parallel Scavenge (used in new generation, using replication algorithm), Parallel old (used in old generation, using marking/collation algorithm)
Implementation of concurrent collector: concurrent mark sweep[CMS ] (used in the old generation, using mark/clear algorithm)
As you can see, each of the above garbage collectors is designed for different memory areas, because they use different algorithms, and they are usually used in the new generation. The ones used for the old generation all use the copy algorithm, and those used for the old generation all use the mark/clear or mark/complement algorithm.
In practical applications, we need to select garbage collectors for the new generation and the old generation of the JVM. We can see that there are three implementations for both the new generation and the old generation. In other words, we should have 3 *3=9 choices. But that is not the case.

In fact, there are only six choices for these six garbage collectors, because some garbage collectors cannot work together due to a series of reasons such as specific implementation methods, as shown below.

In the above picture, the red one is the serial collector, the green one is the parallel collector, and the only yellow one is the concurrent collector. The top three are the collectors of the new generation, and the bottom three are the collectors of the old generation. If there is a connection between the two, it means that the two can work together.
These six combinations do not say which combination is the strongest and which is the weakest. Again, there is only the most suitable, not the best. Therefore, we need to have a certain understanding of each combination in order to choose a more suitable garbage collector when using it.

Conclusion

The above is the content of JVM memory management------garbage collector introduction. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!