Java-Programme werden in einer Java Virtual Machine (JVM) ausgeführt, die einen Manager für alle Ressourcen bereitstellt, die eine Java-Anwendung beim Ausführen benötigt. Dies bedeutet, dass von Entwicklern geschriebene oder erstellte Anwendungen nicht in der Lage sind, Systemressourcen (sei es Hardware oder Software) direkt abzurufen, es sei denn, die JVM kann diese Ressourcen bereitstellen. In Java ist die Programmausführungssequenz also wie folgt:
Die JVM-Schicht ermöglicht die unabhängige Ausführung der Java-Plattform und anderer Programmiersprachen wie z da C/C++ nicht verwendet werden. So etwas wie eine JVM-Schicht, es handelt sich also nicht um plattformübergreifende Sprachen, obwohl es sich um portable Sprachen handelt. Sie sehen wie im Bild unten aus:
Beide Formen haben Vor- und Nachteile, und Java verfügt bereits über ein eigenes Ökosystem. Gleichzeitig haben Programmiersprachen wie C/C++ direkten Zugriff auf Systemressourcen, was der Optimierung der Nutzung von Kerneinheiten förderlicher ist und zu superschnellen und effizienten Programmen führt. Aber beide haben ihren Nutzen in der Welt der Softwareentwicklung.
Alle Programmiersprachen haben viele Ähnlichkeiten im Kompilierungs- und Ausführungsprozess. Der wichtigste Punkt ist die Speicherverwaltung. Unabhängig von der verwendeten Sprache hat die Speicherverwaltung einen wichtigen Einfluss auf die Gesamteffizienz des Programms, denn nur durch eine gute Verwaltung der Speicherressourcen kann die Anwendungsleistung gut verwaltet werden.
Die zugrunde liegende Plattform stellt den von der Anwendung benötigten Speicher bereit. Dies ist eine häufige Situation bei Anwendungen, sodass jede Anwendung optimal ausgeführt werden kann . In Java benötigt das Betriebssystem eine Autorisierung, um die von der JVM bereitgestellten Speicherressourcen nutzen zu können. In Java ist der JVM-Speicher in fünf Hauptteile unterteilt, darunter Methodenbereich, Heap, Stapel, PC-Register und lokaler Methodenstapel.
Dieser Artikel konzentriert sich hauptsächlich auf Heap und Stack. Der Speicher ist kein leeres Blatt Papier. Programmierer können Daten nicht nach Belieben aufschreiben. Sie müssen vor der Verwendung strukturiert werden. Stack und Heap sind die Datenstrukturen, die bei der Speichernutzung befolgt werden. Während der Ausführung eines Programms werden die gespeicherten Daten für verschiedene Zwecke verwendet, je nachdem, welchen Zweck das Programm verfolgt.
Die JVM bestimmt den Laufzeitdatenbereich, der während der Programmausführung verwendet wird. Einige Datenbereiche sind JVM-abhängig, das heißt, sie werden beim Start der JVM erstellt und bleiben während des gesamten JVM-Lebenszyklus bestehen. Allerdings erstellt und zerstört jeder Thread andere Datenbereiche. Die JVM kann mehrere Ausführungsthreads gleichzeitig ausführen, was bedeutet, dass jeder Thread über einen eigenen PC (Programmzähler, Programmzähler) verfügt, um die Position der aktuell ausgeführten Anweisung beizubehalten, und über einen Stapelrahmen, um die statische Speicherzuweisung zu speichern.
Ein Stack ist eine Struktur im Speicher, in der Entwickler Elemente so speichern, dass Daten nur von der Spitze des Stacks abgerufen werden können – oft als „erste“ bezeichnet. rein Zurück raus (FILO oder LIFO). Jeder Thread verfügt über einen privaten JVM-Stack, der Variablen im Zusammenhang mit der statischen Speicherzuweisung speichert. Tatsächlich werden in den in unserem Code deklarierten und verwendeten Methoden bestimmte primitive Variablen im Stapelbereich gespeichert. Darüber hinaus werden auch Verweise auf Objekte, die tatsächlich im Heap-Speicher gespeichert sind, im Stapelbereich gespeichert. Daher wird jeder lokal zugewiesene Speicher auf dem Stapel gespeichert.
Die Standardgröße des Stapelspeichers kann mit dem JVM-Parameter -Xss geändert werden. Manchmal kann der Stapel überlaufen, wenn zu viele Variablen zugewiesen werden oder wenn eine Methode sich selbst rekursiv aufruft. Ein häufiger Fehler, der allen Java-Programmierern bekannt ist, ist Java.lang.stackoverflowerror, der angezeigt wird, wenn nicht genügend Stapelspeicher vorhanden ist. Jeder Methodenaufruf in Java reserviert einen Teil des Speichers auf dem Stapel. Daher können schlecht gestaltete rekursive Methodenaufrufe leicht den gesamten Stapelspeicher belegen und Stapelspeicherüberlauffehler verursachen. Java.lang.stackoverflowerror，当栈内存不足时提示该错误。Java中的每个方法调用都会在栈中分配一块内存，因此，设计糟糕的递归方法调用很容易占用所有栈内存，导致栈内存溢出错误。
堆是JVM一启动就创建的内存区域，它会一直存在，直到JVM被销毁。与栈不同的是，栈是单个线程的属性(因为每个线程都有自己的栈)，堆实际上是由JVM本身管理的全局内存，此内存在运行时用于为对象分配内存。因此，对象的实例化可以是用户定义的类、JDK或其他库类。简而言之，使用new关键字创建的任何对象都存储在堆内存中。堆内存中的对象可被JVM运行的所有线程访问。访问管理非常复杂，使用了非常复杂的算法，这就是JVM垃圾收集器发挥作用的地方。
堆的默认大小可以使用JVM参数-Xms和-Xmx来更改。随着对象的创建和销毁，堆的大小也会增加或减少，如果达到最大内存限制后并尝试进一步分配内存，则抛出java.lang.OutOfMemoryError
new erstellt wurde, wird im Heap-Speicher gespeichert. Auf Objekte im Heap-Speicher kann von allen Threads zugegriffen werden, die die JVM ausführen. Die Zugriffsverwaltung ist sehr komplex und verwendet sehr komplexe Algorithmen. Hier kommt der JVM-Garbage Collector ins Spiel. #🎜🎜##🎜🎜#Die Standardgröße des Heaps kann mit den JVM-Parametern -Xms und -Xmx geändert werden. Wenn Objekte erstellt und zerstört werden, erhöht oder verringert sich auch die Größe des Heaps. Wenn die maximale Speichergrenze erreicht ist und versucht wird, weiteren Speicher zuzuweisen, wird java.lang.OutOfMemoryError ausgelöst. #🎜🎜#Java.lang.String-Klasse ist die am häufigsten verwendete Klasse in Java, daher sollte besonderes Augenmerk auf ihre Effizienz gelegt werden. Im Vergleich zu Basisdatentypen ist die Operationseffizienz von Zeichenfolgen immer sehr langsam. Daher muss eine Methode verwendet werden, um die Effizienz und Benutzerfreundlichkeit von Zeichenfolgenobjektoperationen den Basisdatentypen anzunähern Heap In der JVM wird ein spezieller Speicherbereich (StringPool) zugewiesen, und alle erstellten String-Objekte werden von der JVM im StringPool gespeichert. Dies verbessert die Leistung im Vergleich zu anderen im Heap erstellten Objekten. Java.lang.String类是Java中使用最多的类，因此，应该特别注意它的效率问题。与基本数据类型相比，字符串的操作效率总是很慢，所以，必须采用某种方式使得字符串对象操作的效率和便利性方面类似或者接近于基本数据类型，为了达到这个目的就在堆中分配了一块特殊内存区域(StringPool)，创建的任何字符串对象都由JVM存储在StringPool中。与堆中创建的其他对象相比，这提高了性能。
为了更好地说明在Java中堆和栈内存的使用，让我们写一个简单的程序，并决定哪个分配分配到哪个内存——堆或栈:
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;
}
}这段代码运行方式如下：
程序启动，JVM将Java运行时环境(JRE)类加载到堆中。
在遇到main() 方法时，会创建一个栈帧。
局部变量x和y存储在栈中。
字符串greet分配在堆的StringPool区域中。
Date对象分配在堆区，而它的引用d
Das Programm startet und die JVM lädt die Java Runtime Environment (JRE)-Klasse in den Heap. 🎜main() stoßen, wird ein Stapelrahmen erstellt. 🎜🎜x und y werden auf dem Stapel gespeichert. 🎜🎜greet wird im StringPool-Bereich des Heaps zugewiesen. 🎜🎜Date-Objekt wird im Heap-Bereich zugewiesen und seine Referenz d wird im Stapel gespeichert. 🎜🎜🎜🎜🎜🎜Das obige ist der detaillierte Inhalt vonWas sind Heap und Stack in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
