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

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

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(); 
 }
}

Figure 1-3 Transfer memory allocation of object reference

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

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(); 
 }
}

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!