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

This article introduces what the stack and local variables in JVM are like, the content is very detailed, interested friends can refer to, hope to be helpful to you.

In Java development, whenever we use new to generate an object in a program, the reference to the object is stored in the stack, and the object is stored in the heap. You can see the importance of the stack at the core of the Java. Today we'll dive into the Java core series to introduce you to stacks, local variables, and their relationships in Java.

Stack in Java

Whenever a thread is enabled, JVM assigns it a Java stack that holds the running state of the current thread in frames. The method that a thread is executing is called the current method, the stack frame used by the current method is called the current frame, the class to which the current method belongs is called the current class, and the constant pool of the current class is called the current constant pool. When a thread executes a method, it tracks the current constant pool.

Every time a thread calls a Java method, JVM pushes a frame into the corresponding stack of the thread, which naturally becomes the current frame. When this method is executed, it uses this frame to store parameters, local variables, intermediate operation results, and so on.

All data on the Java stack is private. No thread can access another thread's stack data. So we don't have to consider the synchronization of stack data access in the case of multithreading.

Like the method area and heap, Java stacks and frames do not have to be contiguous in memory. Frames can be distributed in consecutive stacks or in the heap.

The constituent elements of Java stack-stack frame

The stack frame consists of three parts: the local variable area, the Operand stack and the frame data area. The size of the local variable area and Operand stack depends on the corresponding method, and they are calculated by word length. But when a method is called, it gets the method's local variable area and Operand stack size from the type information, allocates stack memory accordingly, and then pushes it into the Java stack.

The local variable area is organized into an array counted from 0 in one word length. Values of types short, byte and char are converted to int values before being stored in the array, while long and double occupy two consecutive items in the array. When accessing long or double in a local variable, you only need to take out the index values of two consecutive items, such as 3 or 4 items when a long value occupies an index in the local variable area. When taking a value, the instruction only needs to take the long value with an index of 3.

Let's take a look at an example so that we can have a deeper understanding of the local variable area. This picture is from "Deep JVM":

Public static int runClassMethod (int iMagneLongl float float double djorObject ojorbyte b) {return 0;} public int runInstanceMethod (char cmagnum double dlemish short smenade Boolean b) {return 0;}

The storage structure of the method parameters and local variables of the above code chip in the local variable area is shown below:

There is nothing to say about the above picture. You will understand it if you look at it. However, in this picture, there is one thing to note:

The local variable area * * item of runInstanceMethod is a reference (reference), which specifies a reference to the object itself, which is our commonly used this, but there is no such reference in the runClassMethod method because runClassMethod is a static method.

Like the local variable area, the Operand stack is organized into an array in terms of word length. But unlike the former, it is not accessed by index, but by going on and off the stack. The Operand stack can be understood as the storage area of temporary data when storing calculations. Let's use a short program clip plus a picture to understand the role of the Operand stack.

Int a = 100

Int b = 98

Int c = aquib

It can be seen from the figure that the Operand stack is actually a temporary data storage area, which operates by entering and leaving the stack.

In the frame data area, in addition to the local variable area and Operand stack, the Java stack frame also needs some data to support constant pool parsing, normal method return and exception dispatch mechanism. These data are stored in the frame data area of the Java stack frame.

When JVM executes an instruction that requires constant pool data, it accesses it through a pointer to the constant pool in the frame data area.

In addition to handling constant pool parsing, the data in the frame also handles the normal and abnormal termination of the Java method. If it ends normally through return, the current stack frame pops up from the Java stack, restoring the stack of the method that initiated the call. If the method returns a value, JVM pushes the return value into the stack of operands that initiated the calling method.

In order to handle an exception in a Java method, the frame data area must also hold a reference to the method exception reference table. When an exception is thrown, JVM gives the code in the catch block. If it is not found, the method terminates immediately, and then JVM uses the information of the frame area data to recover the frame of the method that initiated the call. The context that initiates the calling method then re-throws the same exception.

The whole structure of the stack

As described earlier, the stack is made up of stack frames, and every time a thread calls a Java method, JVM pushes a frame into the corresponding stack of that thread, and the frame is composed of a local variable area, Operand stack, and frame data area. So what exactly is the form of the stack in a code block? Here is an example I extracted from "going deep into JVM", which you can take a look at:

Code snippet:

Three snapshots during execution:

The diagram given above only illustrates two things, which we can also use to understand the stack in Java:

1. Only when a method is called, a frame is assigned to the current stack, and then the frame is pushed onto the stack.

2. The local data of the corresponding method is stored in the frame, and when the method is executed, the corresponding frame pops up from the stack, and the returned result is stored in the Operand stack of the frame in which the method is called.

About how the stack and local variables in JVM is shared here, I hope the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

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.