Java Stack and Heap:zelfstudie over Java-geheugentoewijzing

Wat is stapelgeheugen?

Stack in Java is een geheugengedeelte dat methoden, lokale variabelen en referentievariabelen bevat. Er wordt altijd naar het stapelgeheugen verwezen in de volgorde Last-In-First-Out. Lokale variabelen worden in de stapel gemaakt.

Wat is heapgeheugen?

Heap is een geheugengedeelte dat objecten bevat en dat ook referentievariabelen kan bevatten. Instantievariabelen worden in de heap gemaakt

Geheugentoewijzing in Java

Geheugentoewijzing in Java is het proces waarbij de virtuele geheugensecties opzij worden gezet in een programma voor het opslaan van de variabelen en instanties van structuren en klassen. Het geheugen wordt echter niet toegewezen aan een object bij declaratie, maar er wordt alleen een verwijzing gemaakt. Voor de geheugentoewijzing van het object wordt de methode new() gebruikt, zodat aan het object altijd geheugen op de heap wordt toegewezen.

De Java-geheugentoewijzing is onderverdeeld in de volgende secties:

1. Hoop
2. Stapel
3. Code
4. Statisch

Deze verdeling van het geheugen is nodig voor een effectief beheer.

• De code sectie bevat uw bytecode .
• De Stack geheugengedeelte bevat methoden, lokale variabelen en referentievariabelen.
• De Hoop sectie bevat Objecten (kan ook referentievariabelen bevatten).
• De Statische sectie bevat Statische gegevens/methoden .

Verschil tussen lokale en instantievariabele

Instantievariabele wordt gedeclareerd binnen een klasse, maar niet binnen een methode

class Student{ 
int num; // num is  instance variable 
public void showData{}

Lokale variabele worden verklaard in een methode inclusief methode argumenten .

public void sum(int a){

int x = int a +  3;

// a , x are local variables;

}

Verschil tussen stapel en hoop

Klik hier als de video niet toegankelijk is

Laten we een voorbeeld nemen om dit beter te begrijpen.

Bedenk dat uw belangrijkste methode-aanroepmethode m1

public void m1{
int x=20
}

In de stack-java wordt een frame gemaakt op basis van methode m1.

De variabele X in m1 wordt ook gemaakt in het frame voor m1 in de stapel. (Zie afbeelding hieronder).

Methode m1 roept methode m2 aan. In de stack-java wordt een nieuw frame gemaakt voor m2 bovenop het frame m1.

Variabele b en c worden ook gemaakt in een frame m2 in een stapel.

public void m2(int b){
boolean c;
}

Dezelfde methode m2 roept methode m3 aan. Er wordt opnieuw een frame m3 gemaakt bovenop de stapel (zie onderstaande afbeelding).

Stel nu dat onze methode m3 een object maakt voor de klasse "Account", die twee instanties variabele int p en int q heeft.

Account {
             Int p;
             Int q;
       }

Hier is de code voor methode m3

public void m3(){
	Account ref = new Account();
	// more code
}

De verklaring nieuwe Account() zal een object van account in heap creëren.

De referentievariabele "ref" wordt gemaakt in een stack-java.

De toewijzing "=" operator zal een referentievariabele maken om naar het object in de heap te verwijzen.

Zodra de methode de uitvoering heeft voltooid. De controlestroom gaat terug naar de aanroepmethode. Wat in dit geval methode m2 is.

De stapel van methode m3 wordt leeggemaakt.

Aangezien de referentievariabele niet langer naar het object in de heap wijst, komt deze in aanmerking voor garbagecollection.

Zodra methode m2 zijn uitvoering heeft voltooid. Het wordt uit de stapel gehaald en al zijn variabelen worden leeggemaakt en zijn niet langer beschikbaar voor gebruik.

Hetzelfde geldt voor methode m1.

Uiteindelijk zal de controlestroom terugkeren naar het startpunt van het programma. Wat meestal de "hoofd"-methode is.

Wat als Object een referentie heeft als instantievariabele?

public static void main(String args[]) {
  A parent = new A(); //more code } class A{ B child = new B(); int e; //more code } class B{ int c; int d;  //more code }

In dit geval wordt de referentievariabele "child" gemaakt in heap, die op zijn beurt naar zijn object verwijst, ongeveer zoals het onderstaande diagram.

Samenvatting:

• Als een methode wordt aangeroepen, wordt er een frame bovenaan de stapel gemaakt.
• Zodra een methode is uitgevoerd, keert de controlestroom terug naar de aanroepende methode en wordt het bijbehorende stapelframe leeggemaakt.
• Lokale variabelen worden in de stapel gemaakt
• Instance-variabelen worden in de heap gemaakt en maken deel uit van het object waartoe ze behoren.
• Referentievariabelen worden in de stapel gemaakt.