Detailed explanation of Java's memory mechanism (pictures and text)

This article mainly introduces the relevant knowledge of Java's memory mechanism, which has a very good reference value. Let's take a look at it with the editor

Java divides memory into two types: one One is stack memory, and the other is heap memory. Some basic types of variables and object reference variables defined in the function are allocated in the stack memory of the function. When a variable is defined in a block of code, Java allocates memory space for the variable on the stack. When the scope of the variable is exceeded (for example, when function B is called in function A and variable a is defined in function B, the scope of variable a is only function B. After function B runs, variable a will be automatically destroyed. Assigned to Its memory will be recycled), Java will automatically release the memory space allocated for the variable, and the memory space can be used for other purposes immediately.

Heap memory is used to store the memory array created by new. The memory allocated in the heap is managed by the automatic garbage collector of the Java virtual machine. After generating an array or object in the heap, you can also define a special variable in the stack so that the value of the variable in the stack is equal to the first address of the array or object in the heap memory. The variable in the stack becomes After obtaining the reference variable of the array or object, you can use the variable in the stack to access the array or object in the heap in the program. The reference variable is equivalent to giving a name to the array or object. Reference variables are ordinary variables that are allocated on the stack when defined. The reference variables are released after the program runs outside other scopes. Arrays and objects are allocated in the heap. Even if the program runs outside the code block where the array or object statement generated by new is located, the memory occupied by the array and object will not be released. Arrays and objects only become garbage when there are no reference variables pointing to them and can no longer be used. They will be collected (released) by the garbage collector at an unspecified time later. This is also the reason why Java takes up more memory. In fact, variables in the stack point to variables in the heap memory, which are pointers in Java.

Code example Demo1: Single object creation

class Person {
 String name ;
 int age ;
 public void tell() {
  System.out.println("姓名："+name+",年龄:"+age);
 }
}
public class Demo1 {
 public static void main(String[] args) {
  Person per = new Person() ;
 }
}

In the above program, an object per is instantiated. During the instantiation process, space needs to be opened up in the memory. This includes stack memory and heap memory. The specific memory allocation is shown in the following figure:

## Figure 1-1 Object instantiation process

We can find from the above picture that the object name per is saved in the stack memory (more accurately, the access address of the heap memory space is saved in the stack memory), and the specific content of the object , such as

attributesname and age, are saved in heap memory. Because the per object has only been instantiated and has not been assigned a specific value, it has default values. The default value of string is null, and the default value of type int is 0. As mentioned earlier, the heap memory space must be opened using the new keyword.

Code example Demo2: multiple objects created

class Person {
 String name ;
 int age ;
 public void tell() {
  System.out.println("姓名："+name+",年龄:"+age);
 }
}
public class Demo2 {
 public static void main(String[] args) {
  Person per1 = new Person() ;
  Person per2 = new Person() ;
  per1.name="张三" ;
  per1.age=30 ;
  per2.age=33 ;
  per1.tell(); 
  per2.tell(); 
 }
}

Figure 1-2 Instantiate two objects

Key concepts: Classes, like arrays, are reference types. Reference types mean that the same heap memory can be pointed to by multiple stack memories. Let's take a look at a simple example of reference transfer.

Code example Demo3: Object reference transfer 1

class Person {
 String name ;
 int age ;
 public void tell() {
  System.out.println("姓名："+name+",年龄:"+age);
 }
}
public class Demo3 {
 public static void main(String[] args) {
  Person per1 = new Person() ;
  Person per2 = per1 ;//-------注意--------
  per1.name="张三" ;
  per1.age=30 ;
  per2.age=33 ;
  per1.tell(); 
  per2.tell(); 
 }
}

The program running result is:

From the program The running results show that the output contents of the two objects are the same. In fact, the so-called reference transfer is to transfer the usage rights of one heap memory space to multiple stack memory spaces. Each stack memory space can modify the contents of the heap memory space. , the memory allocation diagram of this program is as follows:

Figure 1-3 Transfer memory allocation of object reference

Figure 1-3 Transfer memory allocation of object reference (continued)

Note: In the above example, the object per2 has no heap memory space. This is because the object per2 only Declaration operations are performed, and no instantiation operations are performed. Just use the new keyword, and there will be heap memory space after instantiation

Code example Demo4: Object reference transfer 2

 class Person {
 String name ;
 int age ;
 public void tell() {
  System.out.println("姓名："+name+",年龄:"+age);
 }
}
public class Demo4 {
 public static void main(String[] args) {
  Person per1 = new Person() ;
  Person per2 = new Person() ;
  per1.name="张三" ;
  per1.age=30 ;
  per2.name="李四" ;
  per2.age=33 ;
  per2=per1 ;//-----注意----
  per1.tell(); 
  per2.tell(); 
 }
}

The result of the above running program is:

It can be found from the output of the program that it is similar to Demo3. However, some changes have occurred in memory allocation, as shown below:

Figure 1-4 (Garbage Object) Generation

Notes:

1. Java itself provides a garbage collection mechanism (Garbage Collection, GC), which will release unused memory space from time to time. As long as the object is no longer used, it will wait for the GC to release the space. , such as name="李思";age=33 in the heap memory above.

2. A stack memory can only point to one heap memory space. If you want to point to another heap memory space, you must first disconnect the existing pointer before allocating a new pointer.

Common memory areas in Java

There are mainly 4 memory spaces in Java. The names and functions of these memories are as follows:

　1. Stack memory space: Saves the names of all objects.

　2. Heap memory space: saves the specific attribute content of each object.

　3. Global data area: Save static type attribute values.

　4. Global code area: saves all method definitions.

The above is the detailed content of Detailed explanation of Java's memory mechanism (pictures and text). For more information, please follow other related articles on the PHP Chinese website!