Detaillierte grafische Erklärung des Java-Speichermechanismus (mit Code)

Java unterteilt den Speicher in zwei Typen: einen ist Stapelspeicher und der andere ist Heap-Speicher. Einige in der Funktion definierte Basistyp-Variablen und ObjektReferenzVariablen befinden sich alle im Stapelspeicher der Funktion Zuweisung, Wenn eine Variable in einem Codeblock definiert ist, reserviert Java Speicherplatz für die Variable auf dem Stapel. Wenn der Gültigkeitsbereich der Variablen überschritten wird (zum Beispiel beim Aufrufen von Funktion B in Funktion A, definieren Sie die Variable a in Funktion B. Der Gültigkeitsbereich der Variablen a ist nur Funktion B. Nach der Ausführung von Funktion B wird die Variable a automatisch zerstört (der ihr zugewiesene Speicher wird wiederverwendet) und Java gibt den Speicherplatz automatisch frei Der Speicherplatz wird für die Variable reserviert und der Speicherplatz kann sofort für andere Zwecke genutzt werden.

　

Heap-Speicher wird zum Speichern von Speicher verwendet, der von neuemArray erstellt wurde, Speicher, der im Heap zugewiesen wird und vom Java Virtual Machine Recycler automatisch Müll wird verwalten. Nachdem Sie ein Array oder Objekt im Heap generiert haben, können Sie auch eine spezielle Variable im Stapel definieren, sodass der Wert der Variablen im Stapel gleich der ersten Adresse des Arrays oder Objekts im Heap-Speicher ist. Die Variable im Stapel wird zur Referenzvariablen des Arrays oder Objekts. In Zukunft können Sie die Variablen im Stapel verwenden, um auf das Array oder Objekt im Heap im Programm zuzugreifen. Die Referenzvariable entspricht der Angabe eines Namens zum Array oder Objekt. Referenzvariablen sind gewöhnliche Variablen, die bei der Definition auf dem Stapel zugewiesen werden. Die Referenzvariablen werden freigegeben, nachdem das Programm außerhalb anderer Bereiche ausgeführt wurde. Arrays und Objekte werden im Heap zugewiesen. Auch wenn das Programm außerhalb des Codeblocks ausgeführt wird, in dem sich die von new generierte Array- oder Objektanweisung befindet, wird der vom Array und Objekt belegte Speicher nicht freigegeben. Arrays und Objekte werden zu Müll, wenn keine Referenzvariablen auf sie verweisen und nicht mehr verwendet werden können. Sie werden zu einem unbestimmten Zeitpunkt später vom Garbage Collector gesammelt (freigegeben). Dies ist auch der Grund, warum Java mehr Speicher beansprucht. Tatsächlich verweisen Variablen im Stapel auf Variablen im Heapspeicher. Dies ist ein Zeiger in Java.

Codebeispiel Demo1: Einzelobjekterstellung

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

Im obigen Programm wird während des Instanziierungsprozesses ein Objekt instanziiert Erstellen Sie Speicherplatz im Speicher, einschließlich Stapelspeicher und Heapspeicher. Die spezifische Speicherzuordnung ist in der folgenden Abbildung dargestellt:

Abbildung 1 -1 Objekt Der Instanziierungsprozess

Aus der obigen Abbildung können wir ersehen, dass der Objektname per im Stapelspeicher gespeichert wird (

Genauer gesagt wird er im Stapelspeicher gespeichert ist die Zugriffsadresse des Heap-Speicherplatzes ) und der spezifische Inhalt des Objekts, wie z. B. der Attributname und das Alter, werden im Heap-Speicher gespeichert. Da das Per-Objekt nur instanziiert wurde und ihm kein bestimmter Wert zugewiesen wurde, verfügt es über Standardwerte. Der Standardwert von string ist null und der Standardwert von int type ist 0. Wie bereits erwähnt, muss der Heap-Speicherplatz mit dem Schlüsselwort new geöffnet werden.

Codebeispiel Demo2: Erstellung mehrerer Objekte

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

　　　　　　 Abbildung 1-2 Instanziieren Sie zwei Objekte

Schlüsselkonzept: Klassen sind wie Arrays Referenztypen, auf die mehrere Stapel verweisen Schauen wir uns ein einfaches Beispiel für die Referenzübergabe an.

Codebeispiel Demo3: Objektreferenzübertragung 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(); 
        
    }
}

Das Ergebnis der Programmausführung ist:

Aus den laufenden Ergebnissen des Programms können wir feststellen, dass

der Ausgabeinhalt der beiden Objekte derselbe ist. Tatsächlich besteht die sogenannte Referenzübertragung darin, die Nutzungsrechte eines Heap-Speicherplatzes zu übertragen Mehrere Stapelspeicherplätze. Sie können den Inhalt des Heapspeicherplatzes ändern Das Speicherzuordnungsdiagramm dieses Programms lautet wie folgt:

　　　　　　　　　 图1-3 对象引用的传递内存分配

 

　　　　　　　　　 图1-3 对象引用的传递内存分配(续)

注意:上述实例中对象per2没有堆内存空间，这是因为对象per2只进行声明操作，也没有进行实例化操作。只是使用new关键字，实例化以后才会有堆内存空间

 代码实例Demo4:对象引用传递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(); 
        
    }
}

 上述运行程序结果为:

从程序的输出结果可以发现跟Demo3差不多。不过内存分配发生了一些变化，具体如下所示:

　　　　　　　　　　　 图1-4 (垃圾对象)的产生

注意点:

 　　1.Java本身提供垃圾收集机制(Garbage Collection,GC),会不定期释放不用的内存空间，只要对象不用了，就会等待GC释放空间，如上面堆内存中的name="李四";age=33。

　　2.一个栈内存只能指向一个堆内存空间，如果要想指向其他堆内存空间，则必须先断开已有的指向，才能分配新的指向。

Java中常见的内存区域

在Java中主要存在4块内存空间，这些内存的名称及作用如下:

　　1.栈内存空间:保存所有对象的名称。

　　2.堆内存空间:保存每个对象的具体属性内容。

　　3.全局数据区:保存static类型的属性值。

　　4.全局代码区:保存所有的方法定义。

Das obige ist der detaillierte Inhalt vonDetaillierte grafische Erklärung des Java-Speichermechanismus (mit Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!