What are heap and stack in Java

How Java programs run

Java programs run in the Java Virtual Machine (JVM). The JVM provides a manager for any resources required by the Java application when it is running. This means that applications written or created by developers do not have the ability to directly obtain system resources (whether hardware or software) unless the JVM can provide these resources. So in Java, the program running sequence is as follows:

The JVM layer enables the Java platform to run independently. Other programming languages, such as C/C, do not use anything similar to the JVM layer. , so they are not cross-platform languages, even though they are portable languages. They look like the picture below:

# Both forms have advantages and disadvantages, and Java already has its own ecosystem. At the same time, programming languages ​​like C/C have direct access to system resources, which is more conducive to optimizing the use of core units, resulting in super-fast and efficient programs. But both have their uses in the world of software development.

All programming languages ​​have many similarities in their compilation and execution processes. The most important point is memory management. No matter which language is used, memory management has an important impact on the overall efficiency of the program, because only by managing memory resources well can the application performance be managed well.

Running Memory in Java

The underlying platform provides the memory required by the application. This is a common situation among applications, allowing each application to operate optimally. In Java, the operating system requires authorization to use the memory resources provided by the JVM. In Java, JVM memory is divided into 5 main parts, including method area, heap, stack, PC register and local method stack.

This article mainly focuses on the heap and stack. Memory is not a blank piece of paper. Programmers cannot write down data at will. It must be structured before use. Stack and Heap are the data structures followed when using memory. During the execution of a program, the data stored is used for various purposes, depending on what the purpose of the program is.

The JVM determines the runtime data area used during program execution. Some data areas are JVM dependent, meaning they are created when the JVM starts and persist throughout the JVM life cycle. However, each thread creates and destroys other data areas. The JVM can execute multiple execution threads at the same time, which means that each thread has its own pc (Program Counter, program counter) to maintain the position of the current instruction being executed, and a stack frame to save the static memory allocation.

Stack

A stack is a structure in memory in which developers store elements in a manner that allows data to be retrieved only from the top of the stack—often called first-in-last-out (FILO) or LIFO). Each thread has a private JVM stack that stores variables related to static memory allocation. In fact, in the methods declared and used in our code, specific primitive variables are stored in the stack area. Additionally, references to objects actually stored in heap memory are also stored in the stack area. Therefore, any locally allocated memory is stored on the stack.

The default size of stack memory can be changed using the JVM parameter -Xss. Sometimes the stack can overflow if too many variables are allocated or if a method calls itself recursively. A common error that all Java programmers know is Java.lang.stackoverflowerror, which is prompted when there is insufficient stack memory. Each method call in Java allocates a piece of memory on the stack. Therefore, poorly designed recursive method calls can easily occupy all stack memory and cause stack memory overflow errors.

Heap

The heap is a memory area created when the JVM is started. It will exist until the JVM is destroyed. Unlike the stack, which is a property of a single thread (because each thread has its own stack), the heap is actually global memory managed by the JVM itself, and this memory is used to allocate memory for objects at runtime. Therefore, the instantiation of the object can be a user-defined class, a JDK or other library class. In short, any object created using the new keyword is stored in heap memory. Objects in heap memory can be accessed by all threads running in the JVM. Access management is very complex and uses very complex algorithms, and this is where the JVM garbage collector comes into play.

The default size of the heap can be changed using the JVM parameters -Xms and -Xmx. As objects are created and destroyed, the size of the heap also increases or decreases. If the maximum memory limit is reached and further allocation of memory is attempted, java.lang.OutOfMemoryError is thrown.

String Pool (StringPool) in the heap

Java.lang.String class is the most used class in Java, therefore, special attention should be paid to its efficiency. Compared with basic data types, the operation efficiency of strings is always very slow. Therefore, some way must be used to make the efficiency and convenience of string object operations similar to or close to basic data types. In order to achieve this purpose, the heap A special memory area (StringPool) is allocated in the JVM, and any string objects created are stored in the StringPool by the JVM. This improves performance compared to other objects created in the heap.

Heap and stack explained from code examples

To better explain the use of heap and stack memory in Java, let us write a simple program and decide which allocation to which memory ——Heap or stack:

public class HeapAndStackTest {
    public static void main(String[] args) {
        int x=10;
        int y=20;
        String greet = "Hello";
        Date d = new Date();
        diff(x, y);
    }

    public static int diff(int x1, int x2) {
        return x2-x1;
    }
}

This code runs as follows:

• The program starts, and the JVM loads the Java Runtime Environment (JRE) class into the heap middle.

• When encountering the main() method, a stack frame will be created.

• Local variables x and y are stored on the stack.

• Stringgreet is allocated in the StringPool area of ​​the heap. The

• Date object is allocated in the heap area, and its reference d is stored in the stack.

The above is the detailed content of What are heap and stack in Java. For more information, please follow other related articles on the PHP Chinese website!