Geheugenbeheer in Java
Wat is stapelgeheugen?
Stack in Java is een geheugengedeelte dat methoden, lokale variabelen en referentievariabelen bevat. Er wordt altijd naar stapelgeheugen verwezen in de volgorde Last-In-First-Out. Lokale variabelen worden in de stapel gemaakt.
Wat is heapgeheugen?
Heap is een gedeelte van het geheugen dat objecten bevat en mogelijk ook referentievariabelen bevat. 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 bij de declaratie echter niet toegewezen aan een object, maar er wordt alleen een referentie gemaakt. Voor de geheugentoewijzing van het object wordt de methode new() gebruikt, zodat het object altijd geheugen op de heap toegewezen krijgt.
De Java Geheugentoewijzing is onderverdeeld in de volgende secties:
- Hoop
- Opstapelen
- Code
- Statisch
Deze verdeling van het geheugen is vereist voor een effectief beheer ervan.
- De code sectie bevat uw bytecode.
- De Opstapelen gedeelte van het geheugen bevat methoden, lokale variabelen en referentievariabelen.
- De Hoop sectie bevat Objecten (kan ook referentievariabelen bevatten).
- De Statisch sectie bevat Statische gegevens/methoden.
Verschil tussen lokale en instantievariabele
Instantievariabele wordt verklaard binnen een klasse, maar niet binnen een methode
class Student{ int num; // num is instance variable public void showData{}
Lokale variabele zijn verklaard binnen a 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. Beschouw dat uw hoofdmethode methode m1 aanroept
public void m1{ int x=20 }
In de stack-java wordt een frame gemaakt volgens methode m1.
De variabele X in m1 wordt ook aangemaakt 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.
Variabelen b en c worden ook in een frame m2 in een stapel aangemaakt.
public void m2(int b){ boolean c; }
Dezelfde methode m2 roept methode m3 aan. Opnieuw wordt een frame m3 aangemaakt bovenaan de stapel (zie afbeelding hieronder).
Laten we nu zeggen dat onze methode m3 een object maakt voor de klasse 'Account', die er twee heeft instanties variabel int p en int q.
Account { Int p; Int q; }
Hier is de code voor methode m3
public void m3(){ Account ref = new Account(); // more code }
De instructie new Account() zal een object van account in heap creëren.
De referentievariabele “ref” wordt gemaakt in een stack-java.
De toewijzingsoperator “=” maakt een referentievariabele die naar het object in de Heap verwijst.
Zodra de methode zijn uitvoering heeft voltooid. De controlestroom gaat terug naar de aanroepende methode. In dit geval is dat methode m2.
De stapel uit methode m3 wordt weggespoeld.
Omdat de referentievariabele niet langer naar het object in de heap verwijst, komt deze in aanmerking voor garbagecollection.
Zodra methode m2 zijn uitvoering heeft voltooid, wordt het uit de stack gehaald en worden alle variabelen geflusht en zijn ze niet langer beschikbaar voor gebruik.
Hetzelfde geldt voor methode m1.
Uiteindelijk zal de controlestroom terugkeren naar het beginpunt van het programma. Dat is meestal de "hoofd"-methode.
Wat als Object een referentie als instantievariabele heeft?
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” in heap aangemaakt, die op zijn beurt naar zijn object zal verwijzen, ongeveer zoals in het onderstaande diagram.
Waar zit afvalinzameling in? Java?
Afvalinzameling in Java is een proces waarbij de programma's automatisch geheugenbeheer uitvoeren. De Garbage Collector (GC) vindt de ongebruikte objecten en verwijdert ze om het geheugen terug te winnen. In Java, dynamische geheugentoewijzing van objecten wordt bereikt met behulp van de new operator die een deel van het geheugen gebruikt en het geheugen toegewezen blijft totdat er referenties zijn voor het gebruik van het object.
Als er geen verwijzingen naar een object zijn, wordt aangenomen dat het niet langer nodig is en kan het geheugen dat door het object wordt ingenomen, worden teruggewonnen. Er is geen expliciete noodzaak om een object te vernietigen Java handelt de toewijzing automatisch af.
De techniek die dit bereikt staat bekend als Garbage Collection. Programma's die de toewijzing van geheugen niet ongedaan maken, kunnen uiteindelijk vastlopen als er geen geheugen meer in het systeem aanwezig is om toe te wijzen. Er wordt gezegd dat deze programma's dat wel hebben geheugenlekken. Afvalinzameling binnen Java gebeurt automatisch tijdens de levensduur van het programma, waardoor de noodzaak om geheugen te de-alloceren wordt geëlimineerd en daardoor geheugenlekken worden vermeden.
In de C-taal is het de verantwoordelijkheid van de programmeur om de toewijzing van dynamisch toegewezen geheugen ongedaan te maken met behulp van de functie free(). Dit is waar Java geheugenbeheer leidt.
Opmerking: Alle objecten worden gecreëerd in Heap Section van het geheugen. Meer hierover in een latere tutorial.
Voorbeeld: Om het afvalverzamelaarmechanisme te leren Java
Stap 1) Kopieer de volgende code in een editor.
class Student{ int a; int b; public void setData(int c,int d){ a=c; b=d; } public void showData(){ System.out.println("Value of a = "+a); System.out.println("Value of b = "+b); } public static void main(String args[]){ Student s1 = new Student(); Student s2 = new Student(); s1.setData(1,2); s2.setData(3,4); s1.showData(); s2.showData(); //Student s3; //s3=s2; //s3.showData(); //s2=null; //s3.showData(); //s3=null; //s3.showData(); } }
Stap 2) Bewaar, compileer en voer de code uit. Zoals weergegeven in het diagram worden er twee objecten en twee referentievariabelen gemaakt.
Stap 3) Verwijder commentaarregel # 20,21,22. Bewaar, compileer en voer de code uit.
Stap 4) Zoals in het onderstaande diagram wordt weergegeven, verwijzen twee referentievariabelen naar hetzelfde object.
Stap 5) Verwijder commentaarregel # 23 en 24. Compileer, bewaar en voer de code uit
Stap 6) Zoals u in het onderstaande diagram kunt zien, wordt s2 nul, maar wijst s3 nog steeds naar het object en komt niet in aanmerking voor Java-garbagecollection.
Stap 7) Verwijder commentaarregel # 25 en 26. Bewaar, compileer en voer de code uit
Stap 8) Op dit moment zijn er geen verwijzingen die naar het object verwijzen en komt het in aanmerking voor garbagecollection. Het wordt uit het geheugen verwijderd en er is geen manier om het terug te halen.
Hoe een object te verwijderen in Java?
1) Als u uw object in aanmerking wilt laten komen voor Garbage Collection, wijst u de referentievariabele toe aan null.
2) Primitieve typen zijn geen objecten. Ze kunnen niet null worden toegewezen.
Overzicht:
- Wanneer een methode wordt aangeroepen, wordt er een frame bovenop de stapel gemaakt.
- Zodra de uitvoering van een methode is voltooid, keert de controlestroom terug naar de aanroepende methode en wordt het bijbehorende stapelframe leeggemaakt.
- Lokale variabelen worden in de stapel gemaakt
- Instantievariabelen worden in de heap gemaakt en maken deel uit van het object waartoe ze behoren.
- Referentievariabelen worden in de stapel gemaakt.