what is garbage collection java
Deze tutorial legt uit wat Garbage Collection in Java is en hoe Garbage Collector werkt. U leert ook over algoritmen voor garbagecollection:
De lezers die bekend zijn met C / C ++ moeten zich ervan bewust zijn dat het de verantwoordelijkheid van de programmeur is om de objecten in C / C ++ te maken en te verwijderen.
Ernstige fouten ontstaan als de programmeur vergeet de gemaakte objecten te vernietigen. Dit komt omdat het niet vernietigen van de objecten kan leiden tot ' OutOfMemory ”Fouten, geheugenlekken, enz.
Deze situatie is volledig opgelost in Java, aangezien er geen programmeur nodig is om de objecten bij te houden. Java zorgt voor de vernietiging van objecten voor ons door middel van automatische garbage collection.
Bezoek hier om Java vanaf het begin te leren.
Het proces waarmee de objecten die niet langer in gebruik zijn, uit het heapgeheugen worden verwijderd, wordt 'Garbage Collection' genoemd. De garbage collection-techniek is een onderdeel van geheugenbeheer in Java.
Dus in Java vernietigt de Garbage Collector alle objecten die niet meer in gebruik zijn.
Wat je leert:
- Wat is een vuilnisman in Java?
- Hoe werkt garbagecollection in Java?
- Garbage Collection-algoritmen in Java
- Gevolgtrekking
Wat is een vuilnisman in Java?
Garbage Collection in Java wordt beheerd door een programma genaamd Garbage Collector.
Garbage Collector kan worden gedefinieerd als een programma dat wordt gebruikt om het geheugen automatisch te beheren door de objectontoekenning af te handelen.
We weten dat in de Java-taal de nieuwe objecten worden gemaakt en geheugen wordt toegewezen met behulp van de nieuwe operator. Het geheugen dat aan een object is toegewezen met een nieuwe operator, blijft toegewezen totdat de referenties dit object gebruiken.
Zodra de referenties ophouden te bestaan, wordt het geheugen dat het object inneemt teruggewonnen. Java zorgt dan automatisch voor het ongedaan maken of vernietigen van objecten en we hoeven het object niet expliciet te vernietigen.
Deze techniek is de Garbage Collection-techniek in Java, waarbij de programmeurs de toewijzing van objecten niet expliciet hoeven af te handelen.
Merk op dat als de programma's het geheugen niet vrijgeven wanneer de objecten het niet nodig hebben, er uiteindelijk geen geheugen meer is om toe te wijzen en de programma's zullen crashen. Deze situatie wordt een geheugenlek genoemd.
De garbage collector draait altijd op de achtergrond op een daemon-thread. Garbage Collector wordt beschouwd als het beste voorbeeld van de daemon-thread.
Garbage Collector wordt uitgevoerd met de bedoeling het heapgeheugen vrij te geven. Het doet dit door de objecten te vernietigen die 'onbereikbaar' zijn.
Wat is een 'onbereikbaar' object?
Een object wordt onbereikbaar als er zelfs geen enkele referentie aan is gekoppeld.
Beschouw het volgende stuk code:
Zoals blijkt uit de bovenstaande code, is een object bereikbaar zolang er een referentie aan is gekoppeld. Op het moment dat de verwijzingsassociatie wordt verwijderd (een instelling van een verwijzing naar null in het bovenstaande geval) wordt het object onbereikbaar.
Wanneer een object onbereikbaar wordt, komt het in aanmerking voor Garbage Collection (GC).
Hoe kunnen we een object geschikt maken voor GC?
Hoewel de programmeur de objecten niet hoeft te vernietigen zoals ze door GC worden verzorgd, kan de programmeur deze objecten in ieder geval onbereikbaar maken wanneer ze niet langer nodig zijn.
Door dit te doen, zal GC de onbereikbare objecten verzamelen en vernietigen.
Er zijn enkele manieren om een object in aanmerking te laten komen voor GC door het onbereikbaar te maken.
Zij zijn:
# 1) Maak de referentie ongeldig
Gegeven een verwijzing die aan een object is toegewezen, als dit object niet langer nodig is, wijs dan de verwijzing toe aan null.
Als s is ingesteld op null, wordt het Student-object onbereikbaar.
# 2) Wijs The Reference opnieuw toe
Dit is een andere manier om de objecten in aanmerking te laten komen voor GC.
Beschouw de volgende code.
Nu we s1 aan een ander object hebben toegewezen, wordt het Student-object waarnaar wordt verwezen door s1 niet meer verwezen.
# 3) Maak een anoniem object
Door een anoniem object te maken kunnen we de objecten geschikt maken voor GC.
We kunnen een anoniem object maken zoals hieronder weergegeven:
Zodra we de objecten voor GC in aanmerking hebben genomen, kunnen deze objecten al dan niet direct door GC worden vernietigd. Dit komt omdat we de GC niet expliciet kunnen dwingen om uit te voeren wanneer we maar willen.
Wanneer draait de Garbage Collector?
Het is aan de JVM om het Garbage Collector-programma uit te voeren. Wanneer JVM de Garbage Collector uitvoert, worden de onbereikbare objecten vernietigd. Maar toch kunnen we niet garanderen wanneer de JVM zal draaien.
Hoewel we de GC niet tot uitvoering kunnen dwingen, kunnen we heel goed een Garbage Collection aanvragen.
De GC kan worden aangevraagd met een van de volgende methoden.
# 1) System.gc (): De systeemklasse van Java biedt een statische methode gc () waarmee we de JVM kunnen verzoeken Garbage Collector uit te voeren.
# 2) Runtime.getRuntime (). Gc (): Net als System.gc () kunnen we ook de methode gc () van 'Runtime class' gebruiken om JVM te vragen Garbage Collector uit te voeren.
Notitie: Er is geen garantie dat de Garbage Collector zal werken na een verzoek van deze twee methoden.
Afronding
Finalisatie wordt uitgevoerd door Garbage Collector net voordat de objecten worden vernietigd. Als onderdeel van de finalisatietechniek roept de Garbage Collector de methode finalize () op het object aan. De methode finalize () wordt gebruikt om opschoonactiviteiten uit te voeren.
De methode finalize () wordt geleverd door de klasse 'Object' en heeft het volgende prototype.
De methode finalize () wordt aangeroepen wanneer het object wordt opgehaald
Notitie: De Garbage collector verzamelt alleen de objecten die zijn gemaakt met het nieuwe trefwoord. Voor andere objecten moeten we de methode finalize () gebruiken om de opschoning uit te voeren.
Het onderstaande programma toont een eenvoudige Garbage Collection in Java.
Uitvoer
In het bovenstaande programma hebben we een klasse TestGC gemaakt. In deze klasse hebben we de methode finalize () overschreven. Vervolgens maken we in de hoofdklasse twee objecten van de TestGC-klasse. Eerst maken we een object ongeldig en roepen we System.gc () aan om Garbage Collector aan te vragen.
Vervolgens maken we het tweede object ongeldig en roepen we methode Runtime.getRuntime.gc () aan om Garbage Collector aan te vragen. De uitvoer toont de uitvoer van de afrondingsmethode tweemaal, waarmee wordt aangegeven dat de Garbage Collector tweemaal is uitgevoerd.
Notitie: Hoewel we deze uitvoer hebben, is het niet gegarandeerd dat we elke keer dezelfde uitvoer krijgen. Het hangt volledig af van JVM.
Hoe werkt garbagecollection in Java?
In deze sectie zullen we zien hoe Garbage Collection werkt in Java.
Tijdens de garbagecollection zoekt de Garbage Collector het Heap-geheugen op en 'markeert' de onbereikbare objecten. Dan vernietigt het ze.
Maar het probleem doet zich voor wanneer het aantal objecten toeneemt. Naarmate het aantal objecten toeneemt, neemt ook de tijd die Garbage Collection in beslag neemt toe naarmate het zoekt naar onbereikbare objecten. Het heeft echter niet al te veel invloed, aangezien de meeste objecten een korte levensduur hebben.
Het bovenstaande gedrag wordt genoemd 'Generational Garbage Collection' en zou de JVM-prestaties moeten verbeteren. Bij deze benadering wordt de volledige Heap-ruimte onderverdeeld in: Young Generation, Old of Tenured Generation en Permanent Generation.
# 1) Heap-ruimte voor jonge generatie: Alle nieuwe objecten worden in deze ruimte gemaakt. Zodra de ruimte vol is, vindt Minor GC plaats waarin alle dode objecten worden vernietigd. Het kleine GC-proces is snel en snel omdat de meeste objecten dood zijn. De objecten die de jonge generatie overleven, worden verplaatst naar de oudere generaties.
# 2) Heap-ruimte van de oude generatie: Deze generatie slaat objecten op die lang overleven. Wanneer de drempelwaarde voor de jonge generatie wordt gehaald, wordt het object verplaatst naar de oude generatie. Wanneer de oude generatieruimte is gevuld, wordt een Major GC uitgevoerd.
Grote GC is traag, aangezien de betrokken objecten levende objecten zijn. Soms wordt de hele Heap-ruimte, die zowel jonge als oude generaties omvat, gewist. Dit wordt 'Full GC' genoemd.
# 3) Permanente generatie L. Tot Java 7 was er een permanente generatie (Perm Gen). De metadata van Perm Gen werd gebruikt door JVM. JVM heeft deze metadata gebruikt om klassen en methoden te beschrijven die in de applicatie worden gebruikt. De Perm Gen is verwijderd in Java 8.
Java 8 Garbage Collection: Perm Gen en Metaspace
We hebben het al gehad over Perm Gen-ruimte die aanwezig was tot Java 7. Nu echter in Java 8 vertegenwoordigt de JVM de klasse-metadata met behulp van het native geheugen genaamd 'Metaspace'.
Naast Metaspace is er een nieuwe vlag genaamd 'MaxMetaspaceSize' die het geheugen beperkt dat wordt gebruikt voor metagegevens van klassen. Als er geen waarde is opgegeven voor MaxMetaspaceSize, wordt de grootte van Metaspace tijdens runtime aangepast aan de vraag van de toepassing.
Wanneer de metagegevensruimte van de klas MaxMetaspaceSize bereikt, wordt de Metaspace GC geactiveerd. Wanneer er overmatige Metaspace GC is, duidt dit op geheugenlekkage van klassen, classloaders, enz. Evenals op onvoldoende grootte.
Garbage Collection-algoritmen in Java
Er zijn verschillende manieren waarop de Garbage Collection wordt uitgevoerd. In deze sectie zullen we vier van dergelijke manieren of algoritmen voor Garbage Collection in Java presenteren.
Seriële GC
Seriële GC is het eenvoudigste GC-algoritme. Het werkt voornamelijk op kleine heapformaten en systemen met één schroefdraad. Tijdens het werken bevriest Serial GC alle applicaties.
Om Serial GC in te schakelen, kunnen we de volgende JVM-optie gebruiken.
desktop support interview vragen en antwoorden pdf
De bovenstaande opdracht kan worden gegeven op de opdrachtregel. Hier is Application.java een bestand waarvoor seriële GC moet worden ingeschakeld.
Doorvoer / parallelle GC
HET parallelle GC-algoritme is het standaardalgoritme in JDK 8. Dit algoritme gebruikt meerdere threads om de heapruimte en verdichting te scannen. Dit algoritme is vooral geschikt voor toepassingen die threadpauzes aankunnen en de CPU-overhead optimaliseren.
Een nadeel van parallelle GC is dat tijdens het uitvoeren van kleine of volledige GC, het algoritme de applicatiedraden pauzeert.
De CMS Collector
Het CMS staat voor “ Gelijktijdige Mark Sweep Dit algoritme maakt gebruik van meerdere gelijktijdig threads om de hoop te scannen ( Mark ) om ongebruikte objecten te identificeren en te recyclen ( vegen ) hen. De CMS-verzamelaar heeft een modus Stop-The-World (STW).
De verzamelaar gaat in deze modus in twee scenario's:
- Wanneer objecten die tot de oude generatie behoren, kunnen worden bereikt vanuit statische variabelen of threadingangspunten. Deze modus is dus ingeschakeld tijdens de initialisatie van de initiële basismarkeringen.
- Wanneer het algoritme gelijktijdig wordt uitgevoerd, verandert de toepassing de status en dwingt de verzamelaar terug te gaan om er zeker van te zijn dat de juiste objecten zijn gemarkeerd.
De CMS-verzamelaar kan echter last hebben van 'mislukte promoties'. Dus wat is een promotionele mislukking? Als de objecten uit de jonge generatie ruimte worden verplaatst naar de oude generatie, en de verzamelaar heeft niet genoeg ruimte voor deze objecten gemaakt in de oude generatie heap space, dan treedt er een promotionele mislukking op.
Om het mislukken van promoties te voorkomen, kunnen we meer achtergrondthreads aan de verzamelaar leveren of meer heap-grootte aan de oude generatie.
De G1 Collector
De G1 Collector is de 'Garbage-First' Collector. Het is ontworpen voor heapgroottes van meer dan 4 GB. Op basis van de heapgrootte wordt de heapgrootte opgedeeld in regio's met een grootte variërend van 1 MB tot 32 MB.
G1-verzamelaar markeert de objecten afhankelijk van de levendigheid van de objecten op de hoop. Na deze markeringsfase is G1 zich bewust van de lege gebieden. Zo verzamelt het de onbereikbare objecten uit deze gebieden en maakt zo een grote hoeveelheid ruimte vrij. Daarom wordt het Garbage-First genoemd omdat het eerst regio's met afval verzamelt.
Het voldoet ook aan het door de gebruiker gedefinieerde pauzetijddoel door een pauzevoorspellingsmodel te gebruiken door het aantal te verzamelen regio's te selecteren, afhankelijk van het gespecificeerde pauzetijddoel.
Voordeel van garbagecollection
- Garbage Collection maakt geheugenbeheer in Java efficiënt omdat het objecten zonder verwijzing uit het heapgeheugen verwijdert zonder tussenkomst van de programmeur.
- Omdat Garbage collection automatisch is en onderdeel uitmaakt van JVM, zijn er geen extra inspanningen van de programmeur nodig om geheugen terug te winnen of objecten te vernietigen.
- De programmeur hoeft geen specifieke code te schrijven om het geheugen vrij te geven en objecten te verwijderen zoals gedaan in C / C ++.
Veel Gestelde Vragen
V # 1) Wat is de rol van een Garbage Collector?
Antwoord: In Java is de Garbage Collector de belangrijkste partij in het geheugenbeheer en heeft de taak de onbereikbare objecten te verzamelen en het geheugen terug te winnen.
Vraag 2) Wat bedoel je met Garbage Collection?
Antwoord: Garbage collection is de techniek waarmee het geheugen automatisch wordt beheerd door het ongebruikte geheugen terug te winnen. Het is een functie die aanwezig is in programmeertalen zoals Java, waardoor de programmeurs de ongebruikte objecten niet hoeven bij te houden en ze te vernietigen. Het gebeurt automatisch met Garbage Collection.
Q # 3) Wie is verantwoordelijk voor Garbage Collection in Java?
Antwoord: Het geheugenbeheer van Java valt onder de verantwoordelijkheid van Garbage Collection.
Q # 4) Hoe kunnen we Garbage Collection in Java voorkomen?
Antwoord: Aangezien de Garbage Collector het geheugen van variabelen / objecten die in leven zijn niet terugwint, is de beste manier om Garbage Collection te voorkomen, door het hele programma variabelen / objecten te blijven gebruiken.
Q # 5) Hoe zorg je ervoor dat een object Garbage wordt opgehaald?
Antwoord: Een object komt in aanmerking voor Garbage Collection wanneer het onbereikbaar is, d.w.z. wanneer er geen referenties meer naar het object verwijzen. Hoewel we de Garbage Collector niet kunnen dwingen te draaien wanneer we maar willen, kunnen we hem altijd vragen om te draaien met System.gc ().
Gevolgtrekking
De Garbage Collection in Java die we in deze tutorial hebben besproken, is automatisch en de programmeur hoeft zich geen zorgen te maken over het verwijderen van de objecten of variabelen die in het programma zijn toegewezen.
Automatische garbagecollection in Java is het belangrijkste kenmerk van de taal en maakt deel uit van geheugenbeheer in Java.
Hoewel Garbage Collection wordt uitgevoerd door JVM en buiten het bereik van de programmeur ligt, kunnen we de Garbage Collector altijd verzoeken om de methode gc () van de System en Runtime-klasse te gebruiken.
In deze tutorial hebben we het voltooiingsproces besproken dat wordt uitgevoerd voordat de objecten worden vernietigd door Garbage Collector. We hebben ook het proces van de Garbage Collection in Java besproken. Ten slotte hebben we de verschillende algoritmen besproken die door de Garbage Collector worden gebruikt.
Hiermee is onze discussie over Garbage Collector in Java voltooid.
Bekijk hier de eenvoudige Java-trainingsserie.
Aanbevolen literatuur
- Java Basics: Java Syntax, Java Class en Core Java Concepts
- Waar wordt Java voor gebruikt: 12 Real World Java-applicaties
- Zelfstudie voor Java String | Java String-methoden met voorbeelden
- JAVA-zelfstudie voor beginners: 100+ praktische Java-videotutorials
- Java-componenten: Java-platform, JDK, JRE en Java Virtual Machine
- Java-implementatie: creatie en uitvoering van Java JAR-bestand
- Java Virtual Machine: hoe JVM helpt bij het uitvoeren van Java-applicaties
- Zelfstudie over reflectie in Java met voorbeelden