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

Today, I will talk to you about how to understand the basic structure of the java virtual machine, which may not be well understood by many people. In order to make you understand better, the editor has summarized the following contents for you. I hope you can get something from this article.

1. Architecture of java virtual machine

Class loading subsystem: responsible for loading class information from the file system or network, and the loaded class information is stored in a memory space called the method area. In addition to class information, the method area may also store runtime constant pool information, including string literals and numeric constants (this constant information is the memory mapping of the constant pool part of the class file).

Java heap: the java heap is established when the virtual machine starts, and it is the main memory working area of the java program. Almost all java object instances are stored in the java heap. Heap space is shared by all threads, which is an area of memory that is closely related to java applications.

Direct memory: java's NIO library allows programs to use direct memory. Direct memory is an area of memory that is outside the java heap and is requested directly from the system. In general, accessing direct memory is faster than the java heap. Therefore, for performance reasons, direct memory may be considered in situations where reads and writes are frequent. Because of the direct memory outside the java heap, its size is not directly limited by the maximum heap size specified by Xmx, but the system memory is limited, and the sum of java heap and direct memory is still limited by the maximum memory of the operating system.

Garbage collection system: the garbage collection system is an important part of the java virtual machine. The garbage collector can collect the normal area, java heap and direct memory. Among them, java heap is the focus of garbage collector. All object space releases in java are implicit, unlike CAccord Category +. That is, there is no function in java like free () or delete () that frees up a specified area of memory. For garbage objects that are no longer in use, the garbage collection system works silently in the background, silently finding, identifying, and releasing garbage objects, and completes fully automated management, including java heap, method zone, and direct memory.

Each java virtual machine thread has a private java stack, a thread's java stack is created when the thread is created, the frame information is stored in the java stack, and the local variables and method parameters are stored in the java stack, which is closely related to the call and return of java methods.

The local method stack is very similar to the java stack, except that the java stack is used for method calls, while the local method stack is used for local method calls. As an important extension to the java virtual machine, the java virtual machine allows java to call local methods directly (usually written in C).

The PC (Program Counter) register is also a private space for each thread, and the java virtual machine creates PC registers for each Java thread. At any given time, a Java thread is always executing a method, and the method being executed is called the current method. If the current method is not a local method, the PC register points to the instruction that is currently being executed. If the current method is a local method, the value of the PC register is undefined

The execution engine is one of the core components of the java virtual machine, which is responsible for executing the bytecode of the virtual machine. In order to improve the execution efficiency, the modern virtual machine will use just-in-time compilation technology to compile the method into machine code before execution.

2. Java heap

Depending on the java recycling mechanism, the java heap may have a different structure. One of the most common constructs is to divide the entire java heap into a new generation and an old age. Among them, the new generation stores the new or young objects, while the old ones store the old ones. The new generation may be divided into eden area, S0 area, S1 area, S0 area and S1 area, also known as from and to area. they are two memory spaces of the same size and can exchange roles.

3. Java stack

The java stack is a thread-private memory space. If the java heap is closely related to program data, then the java stack is closely related to thread execution. The basic behavior of thread execution is function call, and the data of each function call is passed through the java stack.

The main content saved in the java stack is the stack frame. Every time a function is called, a corresponding stack frame is pushed into the java stack, and every function call ends, a stack frame is popped out of the java stack. As shown below:

Function 1 corresponds to stack frame 1, function 2 corresponds to stack frame 2, and so on. The frame corresponding to the function currently being executed is the current frame (at the top of the stack), which stores the local variables of the current function, intermediate calculation results and other data.

When the function returns, the stack frame is popped up from the java stack, and the java method area has two ways to return the function, one is the normal function return, using the return instruction, the other is to throw an exception. No matter which method is used, it will cause the stack frame to be popped.

The java virtual machine provides the parameter-Xss to specify the maximum stack space of the thread, which also directly determines the maximum depth of the function call:

Private static int count = 0 th public static void recursion () {count++; recursion ();} public static void main (String [] args) {try {recursion ();} catch (Throwable e) {System.out.println ("deep of calling =" + count); e.printStackTrace ();}}

Using the-Xss256K parameter, the result is as follows:

You can see that a stack overflow error occurred after about 2900 calls. A deeper call level can be obtained by increasing the value of-Xss. If you try to use the parameter-Xss512K, you can see a significant increase in the number of calls:

In a stack frame, there are at least several parts of the local variable table, the Operand stack and the frame data area.

1 local variable scale

The table of local variables is used to hold the parameters of the function as well as local variables. The local variables in the table are only valid in the current function call. When the function call ends, the function stack frame is destroyed, and the local variable table is also destroyed.

Because the local variable table is in the stack frame, if the function has more parameters and local variables, it will expand the local variable table, so that each function call will occupy more stack space, resulting in a reduction in the number of nested calls to the function.

In the following code, the first recursion () function has 3 parameters and 10 local variables, so its local variable table contains 13 variables, while the second recursion () function contains no parameters and local variables. When these two functions are nested, the second rescursion () function can have a deeper invocation level.

Private static int count = 0; public static void recursion (long a, long b, long c) {long e = 1, f = 2, g = 3, h = 4, I = 5, k = 6, Q = 7, x = 8, y = 9, z = 10; recursion (a, b, c);} public static void recursion () {count++; recursion () } public static void main (String [] args) {try {recursion ();} catch (Throwable e) {System.out.println ("deep of calling =" + count); e.printStackTrace ();}}

Execute the first rescursion () function in the above code using-Xss256k, and the result is as follows:

Execute the second rescursion () function in the above code using-Xss256k, and the result is as follows:

As you can see, functions with fewer local variables can support deeper function calls under the same stack capacity.

The slot in the local variable table in the stack frame can be reused. If the scope of the local variable exceeds its scope, then the new local variable declared after its scope is likely to reuse the slot of the local variable a, so as to achieve the purpose of saving resources. The variables in the local variable table are also important garbage collection root nodes, and the objects referenced directly or indirectly in the local variable table will not be recycled.

Such as the following code:

Public void localVarGc1 () {byte [] a = new byte [6 * 1024 * 1024]; System.gc ();} public void localVarGc2 () {byte [] a = new byte [6 * 1024 * 1024]; a = null; System.gc ();} public void localVarGc3 () {{byte [] a = new byte [6 * 1024 * 1024] } System.gc ();} public void localVarGc4 () {{byte [] a = new byte [6 * 1024 * 1024];} int c = 10; System.gc ();} public void localVarGc5 () {localVarGc1 (); System.gc () } public static void main (String [] args) {Demo05 d = new Demo05 (); d.localVarGc1 (); / / d.localVarGc2 (); / / d.localVarGc3 (); / / d.localVarGc4 (); / / d.localVarGc5 ();}

In the above code, each localVarGcN () function allocates a piece of 6MB's heap memory and uses local variables to reference this space. You can use the parameter-XX:+PrintGC to execute the above functions respectively, and in the output log, you can see the heap size before and after garbage collection, and then infer whether the byte array has been reclaimed.

In localVarGc1 (), garbage collection occurs immediately after the space is requested, and it is obvious that the space cannot be reclaimed because the byte array is referenced by the variable a. The implementation results are as follows:

[GC (System.gc ()) 8765K-> 6664K (251392K), 0.0041586 secs] [Full GC (System.gc ()) 6664K-> 6515K (251392K), 0.0039022 secs]

In localVarGc2 (), the variable an is set to null before garbage collection, and the byte array is used to lose strong references, so garbage collection can successfully collect the byte array. The implementation results are as follows:

[GC (System.gc ()) 8765K-> 568K (251392K), 0.0012696 secs] [Full GC (System.gc ()) 568K-> 395K (251392K), 0.0039405 secs]

For localVarGc3 (), the local variable an is invalidated before garbage collection. Although variable a has left the scope, the variable a still exists in the local variable table and also points to the byte array, so the byte array still cannot be collected. The implementation results are as follows:

[GC (System.gc ()) 8765K-> 6696K (251392K), 0.0039619 secs] [Full GC (System.gc ()) 6696K-> 6515K (251392K), 0.0039020 secs]

For localVarGc4 (), before garbage collection, not only the variable an is invalidated, but also the variable c is declared, so that the variable c reuses the word of the variable a. Because the variable an is destroyed at this time, the garbage collector can successfully collect the byte array. The implementation results are as follows:

[GC (System.gc ()) 8765K-> 536K (251392K), 0.0010555 secs] [Full GC (System.gc ()) 536K-> 370K (251392K), 0.0033685 secs]

For localVarGc5 (), it first calls localVarGC1 (). Obviously, the byte array is not released in localVarGc1 (), but after localVarGc1 () returns, its stack frame is destroyed and naturally contains all the local variables in the stack frame, so the byte array loses its reference and is collected in the garbage collection of localVarGc5 (). The implementation results are as follows:

[GC (System.gc ()) 8765K-> 6744K (251392K), 0.0034826 secs] [Full GC (System.gc ()) 6744K-> 6539K (251392K), 0.0045563 secs] [GC (System.gc () 6539K-> 6539K (251392K), 0.0007713 secs] [Full GC (System.gc ()) 6539K-> 395K (251392K), 0.0032212 secs] 2. Operand stack

Operand stack is mainly used to save the intermediate results of the calculation process, and colleagues serve as temporary storage space for variables in the calculation process. Operand stack is also an advanced and late-out data structure, which only supports in-stack and out-of-stack operations.

3. Frame data area

Frame data area in order to support constant pool parsing, normal method return and exception handling and so on. Most of the Java bytecode instructions need constant pool access, and the pointer to the constant pool is saved in the frame data area, which makes it convenient for the program to access the constant pool.

Tip: because each function call will produce a corresponding stack frame, which occupies a certain stack space, therefore, if the stack space is insufficient, then the function call can not continue naturally. When the requested stack depth is greater than the maximum available stack depth, the system throws a StackOverflowError stack overflow error. For example:

4. Stack allocation

Stack allocation is an optimization technology provided by the Java virtual machine. Its basic idea is that objects that are private to threads (in this case, objects that cannot be accessed by other threads) can be scattered and distributed on the stack rather than on the heap. The advantage of allocation on the stack is that it can destroy itself at the end of the function call without the intervention of the garbage collector, thus improving the performance of the system.

The allocation on the stack and the technical basis are based on escape analysis. The purpose of escape analysis is to determine whether the scope of the object is possible to escape from the function body.

The following simple example shows the stack allocation for non-runaway objects:

Public static class User {public int id; public String name = "";} public static void alloc () {User u = new User (); u.id = 5; u.name = "geym0909";} public static void main (String [] args) {long b = System.currentTimeMillis (); for (int I = 0; I

< 10_0000_0000; i++) { alloc(); } long e = System.currentTimeMillis(); System.out.println(e - b);} 上述代码在主函数中进行了1亿次alloc()调用来创建对象，由于User对象实例需要占用约16字节的空间，因此累计分配空间将近1.5GB。如果堆空间小于这个值，就必然会发生GC。使用如下参数运行上述代码： -server -Xmx10m -Xms10m -XX:+PrintGC -XX:+DoEscapeAnalysis -XX:-UseTLAB -XX:+EliminateAllocations 这里使用参数-server执行程序，因为在Server模式下，才可以启用逃逸分析。 参数-XX:+DoEscapeAnalysis启用逃逸分析。 -Xms10m、-Xmx10m指定了最大与最小堆空间都是10m -XX:+PrintGC将打印GC日志 -XX:+EliminateAllocations 开启了标量替换（默认打开），允许将对象打散分配在栈上，比如对象拥有id与name两个字段，那么这两个字段将会被视为两个独立的局部变量进行分配。 -XX:-UseTLAB关闭TLAB 程序执行后，结果如下：

Note: on my machine, using the following parameters (that is, no relevant parameters are specified on the stack), there is still no large number of gc logs:

-server-Xmx10m-Xms10m-XX:+PrintGC

If you turn off the escape analysis, the results are as follows:

-server-Xmx10m-Xms10m-XX:+PrintGC-XX:-DoEscapeAnalysis

It can be seen that the escape analysis and stack allocation on my machine is turned on by default.

For a large number of scattered small objects, stack allocation provides a good optimization strategy for object allocation, which is fast on the stack and can effectively avoid the negative impact of garbage collection, but compared with the heap space, the stack space is smaller, therefore, large objects cannot and cannot be allocated on the stack.

5. Method area

Like the heap, the method area is a memory area shared by all threads, which is used to hold the class information of the system, such as class fields, methods, constant pools, and so on. The size of the method area determines how many classes the system can save. If the system defines too many classes, causing the method area to overflow, the virtual machine will also throw a memory overflow error.

In JDK1.6 and JDK1.7, the method area can be understood as the permanent zone (Perm). The permanent zone can be specified with the parameters-XX:PermSize and-XX:MaxPermSize, and by default,-XX:MaxPermSize is 64m. A large permanent area can hold more class information. If the system uses some dynamic proxies, it is possible to generate a large number of classes at run time, and if so, you need to set a reasonable permanent zone size to ensure that there is no permanent zone memory overflow.

In JDK1.8, the permanent zone has been completely removed and replaced by a metadata area, the size of which can be specified using the parameter-XX:MaxMetaspaceSize (a large metadata area allows the system to support more classes), which is a piece of direct memory off the heap. Unlike the permanent zone, if you do not specify a size, by default, the virtual machine consumes all available system memory.

If an exception occurs in the metadata area, the virtual machine will also throw an exception.

4. Summary of java virtual machine parameters

-server: use server mode to start jvm, corresponding to-client, and use client mode to start jvm. For server mode, jvm starts slowly because jvm collects system information and optimizes to improve the efficiency of the program; for client mode, jvm starts faster, but due to insufficient optimization due to lack of runtime information collection, later running efficiency may be reduced.

Parameter-XX:+DoEscapeAnalysis enables escape analysis.

-Xms10m and-Xmx10m specify that the maximum and minimum heap space are both 10m

-Xss256k: specify a stack size of 256k

-XX:+PrintGC will print the GC log

-XX:+EliminateAllocations enables scalar substitution (enabled by default), which allows objects to be scattered and distributed on the stack. For example, if an object has two fields, id and name, these two fields will be allocated as two independent local variables.

-XX:-UseTLAB shuts down TLAB

-XX:PermSize and-XX:MaxPermSize: in JDK1.6 and JDK1.7, method zone can be understood as permanent zone (Perm). The permanent zone can be specified with the parameters-XX:PermSize and-XX:MaxPermSize. By default,-XX:MaxPermSize is 64m.

-XX:MaxMetaspaceSize: in JDK1.8, the permanent zone has been completely removed and replaced by a metadata area, the size of which can be specified using the parameter-XX:MaxMetaspaceSize. This is a piece of direct memory outside the stack. Unlike the permanent zone, if you do not specify a size, by default, the virtual machine consumes all available system memory.

After reading the above, do you have any further understanding of how to understand the basic structure of the java virtual machine? If you want to know more knowledge or related content, please follow the industry information channel, thank you for your support.

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.