Shulou(Shulou.com)06/03 Report--

This article introduces the relevant knowledge of "what are the three components of JVM". In the operation of actual cases, many people will encounter such a dilemma. Next, let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Three major components of JVM: classloading subsystem, runtime data area, and execution engine

1. Program counter (thread private)

The line number indicator of the bytecode executed by the current thread.

two。 Virtual machine stack (thread private)

When each method is executed, a stack frame (Stack Frame) is created to store local variables, Operand stacks, and dynamics.

Links, method exits and other information. Each method is called until the completion of execution, corresponding to a stack frame in the virtual machine stack from the stack to the stack process.

3. Local method stack (thread private)

Service for the Native method (the method written in underlying C) used by the virtual machine.

4. Heap (thread sharing)

The sole purpose of this memory area is to store object instances, where almost all object instances allocate memory. Is the main area managed by the garbage collector, also known as the "GC heap".

Heap size = Cenozoic + old age. Where the heap size can be specified by the parameters-Xms,-Xmx,-Xmn.

By default, the ratio of Young to Old is 1:2 (this value can be specified by the parameter-XX:NewRatio), that is, the size of the heap space of Cenozoic (Young) = 1 XX:NewRatio 3. The size of the heap space of the old age (Old) = 2 stroke 3.

Among them, the Young is subdivided into Eden and two Survivor regions, and these two Survivor regions are named from and to respectively to show the distinction.

By default, Edem: from: to = 8: 1: 1 (which can be set by the parameter-XX:SurvivorRatio), that is, the Cenozoic space size of Eden = 8Comp10, and the Cenozoic space size of from = to = 1x10.

5. Method area-JDK1.8 changed to metaspace-non-heap memory (thread sharing)

Store data such as class information, constants, static variables, code compiled by just-in-time compiler that have been loaded by the virtual machine. In the JDK1.8 version, the permanent generation is discarded and replaced by MetaSpace, which is similar to the permanent generation, which is the implementation of the method area. The biggest difference between them is that the metaspace is not in JVM, but uses local memory. The minimum and maximum values can be specified with-XX:PermSize and-XX:MaxPermSize.

How does 1.JVM determine garbage? GC ROOT (Reachability Analysis)

The object referenced in the virtual machine stack (the local variable table in the stack frame).

The object referenced by JNI (Native method) in the woodland method stack.

The object referenced by the static property of the class in the method area.

An object referenced by a constant in the method area.

2.JVM tuning steps

2.1 print GC log

-XX:+PrintGCDetails-XX:+PrintGCTimeStamps-XX:+PrintGCDateStamps,Tomcat is added directly to the JAVA_OPTS variable

-XX:+HeapDumpOnOutOfMemoryError allows the virtual machine to Dump the current memory heap dump snapshot in the event of a memory overflow for analysis

2.2 key indicators are obtained by analyzing the log

2.3 analyze the causes of GC and optimize JVM parameters

3.JVM View system defaults

Jps: check the process number, jps-l

Jinfo: check the default value, jinfo-flag configuration item process number / jinfo-flags process number

Java-XX:+PrintFlagsFinal version

-XX:+PrintFlagsInitial to view the initial value

-XX:+PrintFlagsFinal to view changes and updates

-XX:+PrintCommandLineFlags default garbage collector

Configuration of common basic parameters of 4.JVM

-Xms: initial size of memory, which defaults to physical memory 1x64 equivalent to-XX:InitialHeapSize

-Xmx: maximum allocated memory, defaults to 1 of physical memory and 4 is equivalent to-XX:MaxHeapSize

-Xss: sets the size of a single thread stack. By default, 512k~1024k is equivalent to-XX:ThreadStackSize.

-Xmn: sets the size of the younger generation

-XX:MetaspaceSize: the essence of meta-space is similar to that of permanent generation, which is the realization of the legal zone in the JVM specification. However, the biggest difference between metaspace and permanent generation is that metaspace is not in the virtual machine, but uses local memory. Therefore, by default, the size of metaspace is limited only by local memory.

-XX:PrintGCDetails: print GC (View: memory occupancy before name GC-> Total memory size of this area after GC)

-XX:SurvivorRatio: sets the proportion of the eden/ S0/S1 space in the Cenozoic generation; by default-XX:SurvivorRatio=8, that is, Eden:S0:S1 = 8 XX:SurvivorRatio=8, that is, the value of Eden:S0:S1 = 8 XX:SurvivorRatio=8 1% SurvivorRatio sets the proportion of the eden area, which is the same as the ratio.

-XX:NewRatio: configure the proportion of the younger generation and the old generation in the heap. By default-XX:NewRatio=2, the new generation accounts for 1, the old age accounts for 2, and the young generation accounts for 1 of the whole heap. NewRatio value is to set the proportion of the old generation, and the new generation is 1.

-XX:MaxTenuringThreshold: sets the maximum age of garbage. The default is 15, and the maximum cannot exceed 15.

5. Garbage collection algorithm and garbage collector (GC algorithm is the methodology, garbage collector is the implementation of the algorithm)

Four garbage collection algorithms

1. Reference count: + 1 when referenced, and vice versa. When 0, it is recyclable (there is a problem with circular references).

two。 Copy: the actual available memory space is reduced to half of the original (wasted space, time-consuming)

Divide the memory into two blocks according to capacity, using only one of them at a time. When this piece of memory is used up, copy the surviving objects to another block, and then clean up the used memory space at once. This makes it easy and efficient to reclaim half of the memory area each time, without considering the problem of memory fragmentation. The disadvantage requires twice as much memory space.

3. Tag cleanup (Mark Sweep): produces memory fragmentation

GC is divided into two phases, marking and clearing. First of all, all recyclable objects are marked, and all marked objects are uniformly recycled after the marking is completed. At the same time, it produces discontiguous memory fragments. Too much fragmentation will cause when the program needs to allocate larger objects later, it will not find enough contiguous memory and will have to trigger GC again.

4. Tag finishing (Mark Compact): compression finishing is inefficient (time-consuming)

It is also divided into two phases, first marking recyclable objects, then moving the surviving objects to one end, and then cleaning up memory beyond the boundary. This method avoids not only the fragmentation problem of the mark-removal algorithm, but also the space problem of the replication algorithm.

Expansion: generally speaking, after the younger generation executes GC, a small number of objects will survive, so the replication algorithm will be chosen, and the collection can be completed by paying a small amount of replication cost for living objects. In the old days, because of the high survival rate of objects and no extra memory space allocation, it was necessary to use the mark-clear or mark-collation algorithm for recycling.

Four kinds of garbage collectors

Serial Serial: it is designed for a single-threaded environment and uses only one thread for garbage collection, pausing all threads. So it is not suitable for the production environment.

Parallel parallelism: multiple garbage collection threads work in parallel, when the user thread is paused, which is suitable for weak interaction scenarios such as scientific computing / big data's first processing.

CMS concurrency: user thread and garbage collection thread execute at the same time (not necessarily parallel, may execute alternately). There is no need to pause user thread (short pause, negligible). It is suitable for scenarios that require response time.

* initial tag (Initial Mark)

* concurrent marking (Concurrent Mark)

* relabel (Remark)

* concurrent cleanup (Concurrent Sweep)

Among them, the two steps of initial marking and relabeling still need to pause the application thread. The initial tag is only to mark the objects to which GC Roots can be directly associated, which is very fast. The concurrent marking stage is to mark recyclable objects, while the re-marking phase is to correct the marking records of that part of the objects whose markup changes are caused by the continued operation of the user program during the concurrent marking period. The pause time in this stage is slightly longer than that in the initial marking phase, but much shorter than the concurrent marking time.

Because the collector thread, which consumes the longest concurrent marking and concurrent cleanup process throughout the process, can work with the user thread, the CMS collector memory collection is executed concurrently with the user, greatly reducing the pause time.

G1: divides the heap memory into several independent areas of equal size (Region), and can predict the pause time, can predict the reason, it can avoid the whole heap collection. G1 tracks the value of garbage accumulation in each Region (the amount of space obtained and the time required for collection), and maintains a priority list in the background, giving priority to the collection of the most valuable Region each time according to the allowed collection time, thus ensuring higher collection efficiency in a limited time.

The work project of the G1 collector is divided into four steps, including:

* initial tag (Initial Mark)

* concurrent marking (Concurrent Mark)

* final tag (Final Mark)

* filter recovery (Live Data Counting and Evacuation)

The initial tag, like CMS, marks the object to which GC Roots can be directly associated. Concurrent tags mark living objects starting with GC Root, which takes a long time, but can also be executed concurrently with the application thread. The final tag is also to correct the part of the tag record that changes the tag due to the continued operation of the user program during the concurrent tag. Finally, the recovery value and cost of each Region are sorted in the screening recovery phase, and the recovery is performed according to the GC pause time expected by the user.

Expand:

The advantages of 1.G1 over CMS:

1) G1 does not produce memory fragmentation

2) the pause can be precisely controlled. The collector divides the whole heap (Cenozoic and old generation) into a number of fixed-size areas, and collects the most areas each time according to the allowed pause time.

two。 Garbage collector combination: default garbage collector-Parallel Scavenge

6. Why the generation?

The objects are classified according to the survival probability, and the objects with long survival time are put into the fixed area, so as to reduce the scanning garbage time and Full GC frequency.

According to the classification of different garbage collection algorithms, to enhance the strengths and avoid weaknesses of the algorithm. Note: Full GC will raise STW (stop the world)

7. Why is survivor divided into two equal pieces of survival space?

Mainly to solve fragmentation. If memory fragmentation is severe, that is, two objects occupy discontiguous memory, and the existing continuous memory is not enough for new objects to store, GC will be triggered.

8. Why is there a heap memory overflow?

Objects that survive GC in the younger generation are copied to the older generation. When there is a shortage of space in the old days, JVM will conduct a complete garbage collection (Full GC) of the old years.

If, after GC, objects copied from the Survivor area cannot be stored, OOM (Out of Memory) will appear.

OOM (Out of Memory) exceptions are common for the following reasons:

1) insufficient memory in the old days: java.lang.OutOfMemoryError:Javaheapspace

2) out of permanent memory: java.lang.OutOfMemoryError:PermGenspace

3) memory leak: code bug, the occupied memory cannot be reclaimed in time.

OOM may occur in all of these memory regions. When you encounter OOM, you can locate the memory overflow in which area according to the exception information.

You can add a parameter-XX:+HeapDumpOnOutMemoryError to make the virtual machine Dump the current memory heap dump snapshot in the event of a memory overflow exception for post-analysis.

Troubleshooting of excessive 9.cpu

Failure phenomenon: the user reported that the web page stuttered seriously and logged in for 2 minutes.

9.1. First use the top command to check the resource usage and find out the one with the highest percentage of cpu.

Top

9.2.ps-ef or jps further locates the process

Ps-ef | grep java

9.3. Navigate to a specific thread or code

Top-Hp pid

Ps-mp pid-o THREAD,tid,time

-m shows all threads

-p processes displayed in the pid list

-o the parameter is followed by a user-defined format

9.4. Convert the required thread ID to hexadecimal

Printf "% x\ n" tid

9.5.jstack print thread stack information

Jstack process ID | grep thread id (hexadecimal thread ID lowercase)-A60 (indicates that the last 60 lines of the line are found)

Expansion

Parameter type: 1. Standard configuration, for example: java-version, java-help 2.Musx parameters (understand), example:-Xlint interpretation and execution,-Xcomp is compiled into native code (first compiled) 3.-XX the first time it is used

Finalize: a method in java.lang.Object that is called when an object is gc, overrides the method and re-assigns a value to the object, that is, it will not be recycled. When garbage collection determines that there are no more references to the object, it is called by the garbage collector on the object. A subclass overrides the finalize method to handle system resources or perform other cleanups.

This is the end of the content of "what are the three components of JVM". Thank you for your reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.