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

This article mainly explains "what are the principles of JVM". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what are the principles of JVM"?

JVM Runtime data area

Thread monopoly

Each thread has its own independent space, which is created and destroyed with the thread life cycle.

Thread sharing

All threads can access this piece of in-memory data, which is created and destroyed with the virtual machine or GC

1 Program Counter Register (program count register)

The name Register comes from the register of CPU, and CPU can run only when the data is loaded into the register.

Registers store field information related to instructions. Due to the limitation of CPU time wheel, many threads will only execute one instruction in a thread at any given time, a processor or a core in a multi-core processor. This will inevitably lead to frequent interruptions or recovery. how can we ensure that there is no difference?

After each thread is created, it will generate its own program counter and stack frame. The program counter is used to store the offset and line number indicator of the execution instruction, and the thread execution or recovery depends on the program counter. Program counters do not affect each other between threads, and memory overflow exceptions do not occur in this area.

1.1. Define

This is a small piece of memory and can be seen as a line number indicator of the bytecode being executed by the current thread. If the current thread is executing:

Java method

The counter records the address of the bytecode instruction being executed by the current thread

Local method

Then the program counter value is undefined

1.2. Action

Program counters (hereinafter referred to as PCR) serve two purposes:

Bytecode interpreter implements code flow control by changing PCR to read instructions sequentially, such as sequential execution, selection, loop and exception handling.

In the case of multithreading, PCR is used to record the location where the current thread executes, so that when the thread is switched back, it can know where the thread last ran.

1.3. Characteristics

A small piece of memory space, [thread private]. Each thread has a separate program counter.

The only area of memory where OOM does not appear.

2. Java virtual machine stack (JVM Stack) 2.1. Define

Compared with the register-based runtime environment, JVM is a stack-based runtime environment. The stack structure is more portable and controllable.

The virtual machine stack in JVM is the memory area that describes the execution of Java methods, which is thread private.

The elements in the stack are used to support the virtual machine to make method calls, and the process of each method from the beginning of the call to the completion of the execution is the process of the stack frame from the stack to the stack.

3. Local method stack (Native Method Stack)

Similar to the virtual machine stack function, the virtual machine stack is prepared for the virtual machine to execute the JAVA method

The virtual machine specification does not specify the specific implementation, which is implemented by different virtual machine manufacturers.

The virtual machine stack and the local method stack are implemented the same in the HotSpot virtual machine. Again, beyond the size,

StackOverflowError will also be found.

The native method stack and the Java virtual machine stack implement almost the same function as throwing an exception

However, the virtual machine stack executes the Java method (bytecode) service for the virtual machine, and the local method area serves the Native method used by the virtual machine.

In the JVM memory layout, thread objects are also private, but the virtual machine stack is "inside" and the local method stack is "outside"

This "inside and outside" is for JVM, and the local method stack serves Native methods.

When a thread starts calling a local method, it enters a world that is no longer constrained by JVM

Local methods can access the data area of the virtual machine runtime through JNI (Java Native Interface), or even call registers, with the same capabilities and permissions as JVM

When a large number of local methods appear, it is bound to weaken JVM's control over the system, because its error messages are black-box.

In the case of insufficient memory, the local method stack will still export native heap OutOfMemory.

The most famous local method should be System.currentTimeMillis (). JNI makes Java deeply use the features of OS and reuse non-Java code.

However, in the course of the project, if a large number of other languages are used to implement JNI, the cross-platform feature will be lost and the stability of the program will be threatened.

If you need to interact with native code, you can decouple it with an intermediate standard framework, so that even if the native method crashes, it does not affect the stability of JVM.

Of course, if you require extremely high execution efficiency, low-level cross-process operations, etc., you can consider designing the JNI call mode.

2.2 structure

Stack frame is the basic structure of method operation.

In an active thread, only the frame at the top of the stack is valid, called the current stack frame

The method being executed is called the current method

When the execution engine is running, all instructions can only operate on the current stack frame. StackOverflowError indicates the stack overflow of the request, resulting in memory exhaustion, which usually occurs in recursive methods.

The stack frame of the current method is the battlefield where the battle is going on, in which the operation stack is the soldiers involved in the battle.

The pressing and unloading of the operation stack

The virtual machine stack calculates the active stack frame corresponding to each method by pressing / exiting the stack. After the normal execution of the method, it will definitely jump to another stack frame.

In the process of execution, if an exception occurs, the exception will be traced back, and the return address is determined through the exception handling table.

Stack frame plays a high role in the whole JVM system, including local variable table, operation stack, dynamic connection, method return address and so on.

Local variable scale

Store method parameters and local variables.

Relative to the preparation phase and initialization phase of class property variables, local variables have no preparation phase and must be explicitly initialized.

If it is a non-static method, the instance reference of the object to which the method belongs is stored at the index [0] position, followed by parameters and local variables.

The STORE instruction in the bytecode instruction is to write the calculated local variables in the operation stack back to the storage space of the local variable table.

Operand stack

A bucket structure stack with an empty initial state. Since Java does not have registers, all parameters are passed using the Operand stack. During the execution of the method, various instructions will write and extract information to the stack. The execution engine of JVM is a stack-based execution engine, in which the stack refers to the operation stack.

The definition of bytecode instruction set is based on the stack type, and the stack depth is in the stack attribute of the method meta-information.

Operation stack interacts with local variable table

The detailed bytecode operation order is as follows:

The first note: the local variable scale is like a traditional Chinese medicine cabinet, which has many drawers, numbered 0, 1, 2, 3. The n-byte code instruction istore_ 1 is to open the No. 1 drawer and store the number 13 at the top of the stack. The stack is a deep vertical bucket, which can only operate on the bucket mouth elements at any time, so the data can only be accessed at the top of the stack.

Some instructions can be performed directly in the drawer, such as the inc instruction, which directly operates on the values in the drawer.

In the process of programmer interview, the common difference between iTunes + and + + I can be compared in bytecode.

Iload_ 1 takes a number from the No. 1 drawer of the local variable table and presses it into the top of the stack. The next step is to realize the + 1 operation directly in the drawer, but this operation has no effect on the value of the top element of the stack, so istore_ 2 only assigns the top element of the stack to a.

In the right column of the table, first perform the + 1 operation in the No. 1 drawer, and then press the number in the No. 1 drawer into the top of the stack through iload_ 1, so istore_ 2 stores the value after + 1, and iTunes + is not an atomic operation. Even if modified by the volatile keyword, multiple threads writing at the same time will cause the problem of data overwriting each other.

Dynamic connection

Each stack frame contains a reference to the current method in the constant pool to support the dynamic connection of the method invocation process.

Method returns the address

There are two kinds of exit cases when the method is executed

Normal exit

Normal execution of return bytecode instructions to any method, such as RETURN, IRETURN, ARETURN, etc.

Abnormal exit

Either way, it returns to the location where the method is currently called. The process of method exiting is equivalent to popping up the current stack frame.

There may be three ways to exit:

The return value is pressed in, and the upper layer calls the stack frame

Exception information is thrown to stack frames that can be processed

The PC counter points to the next instruction after the method call

The Java virtual machine stack is a memory model that describes the running process of the Java method. The Java virtual machine stack creates "stack frames" for each Java method that is about to run. It is used to store some information needed during the operation of the method.

Local variable table: storage of basic data type variables, reference type variables, returnAddress type variables

Operand stack

Dynamic link

Constant pool pointer to the current method

The return address of the current method

Information such as method exit

From the call to the completion of execution, each method corresponds to the stack entry and unstack process of each stack frame in the JVM stack.

Note: it is often said that the memory space of Java is divided into "stack" and "heap", with local variables in the stack and objects in the heap.

This sentence is not entirely true! The "heap" here can be understood this way, but the "stack" here is the virtual machine stack, or the local variable table part of the Java virtual machine stack.

The real Java virtual machine stack is composed of stack frames, and each stack frame has: local variable table, Operand stack, dynamic link, method exit information.

Characteristics

The creation of the local variable table is created as the stack frame is created when the method is executed.

The size of the table is determined at compile time, and you only need to assign a predetermined size when you create it. The size of the table does not change while the method is running. There are two exceptions to the Java virtual machine stack:

StackOverFlowError

If the memory size of the Java virtual machine stack does not allow dynamic expansion, this exception is thrown when the stack depth requested by the thread is greater than the maximum allowed by the virtual machine (but there may be a lot of memory space).

The default maximum stack memory is 1m. If the stack memory is exceeded, StackOverflowError is thrown.

OutOfMemoryError

If the memory size of the Java virtual machine stack allows dynamic expansion, and when the thread requests the stack, the memory is used up and cannot be expanded dynamically, then an OutOfMemoryError exception is thrown.

The Java virtual machine stack is also thread-private, and each thread has its own Java virtual machine stack, which is created as the thread is created and dies as the thread dies.

4 Java heap (Java Heap)

JVM is created when it starts to hold an instance of the object. The garbage collector mainly manages heap memory.

Heap is the main source of OOM failures, it stores almost all instance objects, the heap is automatically collected by the garbage collector, and the heap area is shared by each child thread.

Usually, it takes up the largest space of all memory areas, but if you create a large number of objects without control, it is easy to consume all the space.

The memory space of the heap can be either fixed or dynamically adjusted at run time, setting the initial and maximum values with the following parameters, such as

-Xms256M. -Xmx1024M

Where-X indicates that it is a JVM running parameter

Ms is the abbreviation of memorystart for minimum heap capacity

Mx is the abbreviation of memory max for maximum heap capacity

However, under normal circumstances, during the operation of the server, the heap space is constantly expanding and shrinking, which is bound to form unnecessary system pressure, so in the online production environment, the Xms and Xmx of JVM are set to the same size to avoid the extra pressure caused by adjusting the heap size after GC.

The heap is divided into two large pieces: the new generation and the old age.

The object came into being at the beginning of the new generation, and entered the old age in its twilight years, but the old age also accepted the super-large objects that could not be accommodated in the new generation.

Cenozoic = 1 Eden region + 2 Survivor regions

Most of the objects are generated in the Eden area, and Young GC is triggered when the Eden area is full. During garbage collection, the cleanup policy is implemented in the Eden area, and objects that are not referenced are collected directly. Objects that are still alive will be transferred to the Survivor area, which really exists.

Survivor is divided into S0 and S1 two pieces of memory space, which space should be sent? Each time you Young GC, copy the surviving objects to the unused space, then completely clear the space currently in use, and exchange the usage status of the two spaces.

If the object to be transferred by YGC is greater than the upper limit of the capacity of Survivor zone, it will be handed over directly to the old age.

It would be wrong if some unenterprising objects think that they can always exchange in the Survivor area of the new generation. Each object has a counter, and each YGC is incremented by 1.

-XX:MaxTenuringThreshold

Parameter can configure that when the value of the counter reaches a certain threshold, the object is promoted from the new generation to the old age. If this parameter is configured to 1, it is moved directly from the Eden area of the Cenozoic to the old age. The default value is 15, which can be promoted to the old age after 14 exchanges in the Survivor area.

If the Survivor area cannot be dropped, or if the threshold of the oversized object exceeds the upper limit, try to allocate it in the old age.

If the old age cannot be put down, Full Garbage Collection (Full GC) will be triggered.

If you still can't put it down, throw OOM.

The probability of OOM in the heap is the highest of all memory exhaustion exceptions.

The in-heap information in the event of an error is very helpful in solving the problem, so set the run parameters for JVM-

XX:+HeapDumpOnOutOfMemoryError

Let JVM output in-heap information when it encounters OOM exception.

The partition of heap memory is different in different JVM implementations and different recycling mechanisms.

Store all class instances and array objects

In addition to the instance data, other information about the object is saved, such as Mark Word (storage object hash code, GC flag, GC age, synchronization lock, etc.), Klass Pointy (pointer to storage type metadata) and some byte alignment padding data (if the instance data is exactly 8 bytes aligned, there may be no padding)

Characteristics

The largest piece of memory that a Java virtual machine needs to manage.

Heap memory doesn't have to be physically continuous, it just needs to be logically continuous, just like disk space.

Heap is the main area of garbage collection, so it is also called GC heap.

The heap size can be either fixed or expanded, but the mainstream virtual machine heap size is scalable (controlled by-Xmx and-Xms), so when a thread requests to allocate memory, but the heap is full, and the memory is full and can no longer be expanded, an OutOfMemoryError is thrown.

Thread sharing

The entire Java virtual machine has only one heap, and all threads access the same heap.

It is a memory area shared by all threads and created when the virtual machine starts.

The program counter, the Java virtual machine stack and the local method stack all correspond to one thread.

5 method area 5.1 definition

The method zone defined in the Java virtual machine specification is a logical partition part of the heap, and the specific implementation is implemented according to different virtual machines, such as: HotSpot is placed in the permanent generation in the legal area of Java7, Java8 is placed in the metadata space, and this area is managed through the GC mechanism.

Alias Non-Heap (not heap) to distinguish it from the Java heap. Method area that has been loaded by the virtual machine:

Class information

Constant

Constants are stored in the [runtime constant pool]

Static variable

Data such as code compiled by just-in-time compiler (JIT)

5.2 Features

Thread sharing

The method area is a logical part of the heap, so like the heap, it is shared by threads. There is only one method area in the whole virtual machine.

Permanent generation

The information in the method area generally needs to exist for a long time, and it is the logical partition of the heap, so using the heap partition method, we call the method area permanent generation.

Low memory recovery efficiency

Java virtual machine specification on the other side of the law area requirements are relatively loose, can not achieve garbage collection.

The information in the method area usually needs to exist for a long time, and only a small amount of information may be invalid after reclaiming the memory.

The main objectives of memory recovery in the method area are the recovery of constant pools and the unloading of types.

Like the heap, it allows for fixed size, scalable size, and no garbage collection.

When the method area memory space cannot meet the memory allocation requirements, an OutOfMemoryError exception will be thrown.

5.3 run time Pool (Runtime Constant Pool) 5.3.1 definition

Part of the method area.

The .class file generated after the .java file is compiled contains not only the version, fields, methods, interfaces and other description information of the class, but also the constant pool.

The constant pool stores all kinds of literals and symbolic references generated at compile time, and all the contents in the constant pool in the .class file are stored in the runtime pool in the method area after the class is loaded.

In JDK6, 7, and 8, the area where the running constant pool is located is constantly changing:

At 6: 00, it is part of the method area

At 7: 00, put it in the heap memory again

At 8: 00, meta-space appeared and returned to the method area.

This also shows that the official optimization of the "permanent generation" has started since 7.

5.3.2 Features

Another characteristic of the runtime constant pool relative to the class file constant pool is that it is dynamic. The Java language does not require that constants must be generated only by the compiler, that is, the contents of the constant pool that is not preset into the class file can enter the method area runtime constant pool, and new constants may also be put into the pool during operation.

The intern () method of the String class takes advantage of the dynamic nature of the runtime pool. When the intern method is called, the pool already contains a string equal to this String object:

Yes

Returns the string in the pool

No

Add this String object to the pool and return a reference to this String object

5.3.3 possible exceptions thrown

The runtime pool is part of the method area, so it is limited by the memory of the method area, so an OutOfMemoryError exception is thrown when the constant pool can no longer apply for memory.

We usually declare a constant in a class through public static final. After the class is compiled, the Class file is generated, and all the information about the class is stored in the class file.

When this class is loaded by the Java virtual machine, the constants in the class file are stored in the runtime pool in the method area. And during run time, you can add new constants to the constant pool. For example, the intern () method of the String class can add string constants to the constant pool at run time.

When some constants in the runtime pool are not referenced by objects and are not referenced by variables, then the garbage collector is required to collect them.

6 Direct memory (Direct Memory)

Direct memory is not part of the run-time data area of a virtual machine, nor is it a memory area defined in the JVM specification, but it is frequently used in the actual operation of JVM. And can also throw OOM.

The NIO (New Input/Output) class is added in JDK 1.4.An IO method based on pipes and buffers is introduced, which can use the Native function library to directly allocate out-of-heap memory, and then manipulate the data in the out-of-heap memory through a DirectByteBuffer object stored in the heap as a reference to this memory.

This can significantly improve performance in some scenarios because it avoids copying data back and forth between the Native heap and Java heap.

To sum up,

Program counter, Java virtual machine stack and local method stack are thread private, that is, each thread has its own program counter, Java virtual machine stack and local method area. And their life cycle is the same as the thread they belong to.

The heap and method area are shared by threads, and there is only one heap and one method stack in the Java virtual machine. It is created when the JVM is started and destroyed when the JVM is stopped.

7 Metaspace (Metaspace)

When it comes to JDK8, the predecessor of metaspace, the Perm zone (permanent generation), is obsolete. In JDK7 and previous versions, only Hotspot has a Perm area, which is fixed at startup, difficult to tune, and moves class meta information when Full GC.

In some scenarios, if there are too many classes loaded dynamically, it is easy to generate OOM in the Perm area. For example, because there are many function points in a project, many classes need to be loaded dynamically during operation, and errors often occur:

To solve this problem, you need to set the running parameters

-XX:MaxPermSize= l280m

If deployed to a new machine, the failure will often be reproduced because the JVM parameters have not been modified. People who are not familiar with the app suffer a lot when troubleshooting problems. In addition, there are still many problems in the process of GC.

Therefore, JDK8 replaces the permanent generation with metaspace. Unlike the permanent generation, metaspace is allocated in local memory. That is,

As long as there is enough local memory, it will not appear like the permanent generation of java.lang.OutOfMemoryError: PermGen space

The setting parameters PermSize and MaxPermSize for the permanent generation will also fail. In JDK8 and above, if you set the MaxPermSize parameter, JVM will not report an error when starting, but it will prompt:

Java HotSpot 64Bit Server VM warning:ignoring option MaxPermSize=2560m; support was removed in 8.0

By default, the size of Metaspace can be adjusted dynamically, or the new parameter MaxMetaspaceSize can be used to limit the size of local memory allocated to class metadata.

In JDK8, of all the content in the Perm area

The string constant is moved to heap memory

Other contents, including class meta-information, fields, static properties, methods, constants, etc., are all moved to metaspace.

For example, Object class meta-information, static attribute System.out, integer constant 000000 in the above figure, etc.

The figure shows that the actual objects of the String in the constant pool are stored in heap memory.

Meta-space characteristics

Make full use of the Java language specification: the life cycle of classes and related metadata is consistent with that of class loaders

Each classloader has its memory region-metaspace

Linear assignment only

A class is not recycled separately (except for redefining class RedefineClasses or class loading failure)

No GC scanning or compression

Objects in metaspace will not be transferred

If GC finds that a class loader is no longer alive, it will collectively reclaim the entire metaspace.

GC

When Full GC, pointers to metadata no longer need to be scanned, which reduces the time of Full GC

A lot of complex metadata scanning code (especially those in CMS) have been deleted.

There are only a few pointers to the Java heap in metaspace

This includes pointers to java.lang.Class instances in the metadata of the class, and pointers to the java.lang.Class collection in the metadata of the array class.

No overhead of metadata compression

Reduced GC Root scanning (no longer scanning directories of loaded classes and other internal hash tables in the virtual machine)

In G1, the class can be unloaded after the concurrent marking phase is completed.

Meta-space memory allocation model

The vast majority of class metadata space is allocated in local memory.

Objects used to describe class metadata are also removed

Multiple mapped virtual memory spaces are allocated for metadata

Assign a list of memory blocks to each class loader

The size of the block depends on the type of classloader

The bytecode accessor (sun.reflect.DelegatingClassLoader) reflected by Java takes up less memory

Free block memory is returned to block memory list

When the metaspace is empty, the virtual memory space is reclaimed

Reduced memory fragmentation

Finally, from the perspective of thread sharing

Heap and metaspace are shared by all threads

The virtual machine stack, the local method stack and the program counter are private within the thread

Look at the Java memory structure from this point of view.

8 look at Java heap from the perspective of GC

Both the heap and the method area are areas shared by threads, which are mainly used to store information about objects. Multiple implementation classes in an interface may need different memory, and multiple branches of a method may need different memory, and we can only know which objects will be created while the program is running, so, this part of the memory and collection are dynamic, and this is the part of memory that the garbage collector is concerned with (the "memory" allocation and recycling mentioned later in this section only refers to this part of memory). The allocation of this part of memory is also different in JDK1.7 and 1.8:

The heap memory allocation in Java8 is shown below:

9 JVM off

Normal shutdown: when the last non-daemon thread ends or calls System.exit or in some other platform-specific way, such as ctrl+c.

Force shutdown: call the Runtime.halt method, or kill the JVM process directly in the operating system (sending single signals).

Abnormal shutdown: RuntimeException exception encountered during operation

In some cases, we need to do some clean-up work when JVM shuts down, such as deleting temporary files and stopping logging services. To do this, JVM provides a shutdown hocks to do these events.

The Runtime class encapsulates the environment in which the java application runs. Each java application has an instance of the Runtime class, and the user program can be connected to its runtime environment.

A shutdown hook is essentially a thread (also known as a hock thread), and you can register a shutdown hook with the main jvm through Runtime's addshutdownhock (Thread hock). The hock thread executes when the jvm shuts down normally, and the forced shutdown does not execute.

For multiple close hooks registered in jvm, they execute concurrently, and jvm does not guarantee their execution order.

Thank you for your reading, these are the contents of "what are the principles of JVM". After the study of this article, I believe you have a deeper understanding of the principles of JVM, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.