Meny

Vad är skräpsamling i Java och hur fungerar det

  • Huvud
  • Övrig
  • Vad är skräpsamling i Java och hur fungerar det

what is garbage collection java

Prova Vårt Instrument För Att Eliminera Problem

Denna handledning förklarar vad som är Garbage Collection i Java och hur fungerar Garbage Collector. Du kommer också att lära dig mer om Algorithms for Garbage Collection:

De läsare som är kunniga i C / C ++ måste vara medvetna om att det är programmerarens ansvar att skapa och ta bort objekten i C / C ++.

Allvarliga fel uppstår om programmeraren glömmer att förstöra de skapade objekten. Detta beror på att misslyckande med att förstöra objekten kan orsaka “ Slut på minne ”Fel, minnesläckor etc.

Denna situation tas helt hand om i Java eftersom det inte finns något behov av en programmerare att hålla koll på objekten. Java tar hand om förstörelse av objekt för oss genom automatisk sopuppsamling.

=> Besök här för att lära dig Java från grunden.

Avfallssamling i Java

Processen genom vilken föremål som inte längre används tas bort från högminnet kallas ”Garbage Collection”. Sopuppsamlingstekniken är en del av minneshantering i Java.

Således förstör Garbage Collector i Java alla objekt som inte används längre.

Vad du kommer att lära dig:

Vad är en skräpsamlare i Java?

Garbage Collection i Java hanteras av ett program som heter Garbage Collector.

Garbage Collector kan definieras som ett program som används för att hantera minne automatiskt genom att hantera objektavdelningen.

Vi vet att på Java-språket skapas de nya objekten och tilldelas minne med den nya operatören. Minnet som tilldelats ett objekt med hjälp av en ny operatör förblir allokerat tills referenserna använder detta objekt.

Så snart referenserna upphör att återfås, återvinns minnet som objektet upptar. Java hanterar sedan avdelning eller förstörelse av objekt automatiskt och vi behöver inte uttryckligen förstöra objektet.

Denna teknik är Garbage Collection-tekniken i Java där programmerarna inte behöver hantera deallocation av objekt uttryckligen.

Observera att om programmen inte avdelar minnet när objekten inte behöver det så kommer det så småningom inte att finnas något minne kvar och programmen kommer att krascha. Denna situation kallas minnesläcka.

Sopsamlaren körs alltid i bakgrunden på en demon-tråd. Garbage Collector anses vara det bästa exemplet på daemon-tråden.

Garbage Collector kör i avsikt att frigöra heapminnet. Det gör det genom att förstöra föremål som är 'oåtkomliga'.

Vad är ett 'oåtkomligt' objekt?

Ett objekt blir oåtkomligt när det inte ens är en enda referens associerad med det.

Tänk på följande kod:

Integer ref_obj = new Integer (5); //ref_obj is a reference to Integer ref_obj = null; //Integer object now becomes unreachable

Som framgår av ovanstående kod kan ett objekt nås så länge som en referens är associerad med det. I det ögonblick som referensassociationen tas bort (en inställningsreferens till null i ovanstående fall) blir objektet oåtkomligt.

När ett objekt blir oåtkomligt blir det kvalificerat för Garbage Collection (GC).

Hur kan vi göra ett objekt berättigat till GC?

Även om programmeraren inte är skyldig att förstöra objekten eftersom de tas om hand av GC, kan programmeraren åtminstone göra dessa objekt oåtkomliga när de inte längre behövs.

Genom att göra detta samlar GC de oåtkomliga föremålen och förstör dem.

Det finns några sätt att göra ett objekt kvalificerat för GC genom att göra det oåtkomligt.

Dom är:

# 1) Nullifiera referensen

Med en referens som tilldelats ett objekt, om detta objekt inte längre behövs, tilldela referensen till null.

Student s = new Student (); s = null;

När s är satt till null blir Student-objektet oåtkomligt.

# 2) Tilldela referensen igen

Detta är ett annat sätt att göra objekten kvalificerade för GC.

Tänk på följande kod.

Student s1 = new Student (); Student s2 = new Student (); s1 = s2;

Nu när vi har tilldelat s1 till ett annat objekt, hänvisas studentobjektet som refereras till av s1.

# 3) Skapa ett anonymt objekt

Genom att skapa ett anonymt objekt kan vi göra objekten kvalificerade för GC.

Vi kan skapa ett anonymt objekt som visas nedan:

new Student();

När vi väl har gjort objekten berättigade till GC kan dessa objekt förstöras omedelbart av GC. Detta beror på att vi inte uttryckligen kan tvinga GC att köra som och när vi vill.

När kör skräpsamlaren?

Det är upp till JVM att köra Garbage Collector-programmet. När JVM kör Garbage Collector förstörs de oåtkomliga föremålen. Men ändå kan vi inte garantera när JVM kommer att köras.

Även om vi inte kan tvinga GC att köra, kan vi mycket väl begära en skräpsamling.

GC kan begäras med någon av följande metoder.

# 1) System.gc (): Systemklassen för Java tillhandahåller en statisk metod gc () med vilken vi kan begära att JVM kör Garbage Collector.

# 2) Runtime.getRuntime (). Gc (): Liksom System.gc () kan vi också använda gc () -metoden i 'Runtime-klass' för att begära JVM att köra Garbage Collector.

Notera: Det finns ingen garanti för att Garbage Collector kommer att köras efter en begäran från dessa två metoder.

Slutförande

Slutförandet utförs av Garbage Collector precis innan objektet förstörs. Som en del av finaliseringstekniken kallar Garbage Collector metoden finalize () för objektet. Metoden finalize () används för att utföra saneringsaktiviteter.

Finalize () -metoden tillhandahålls av klassen 'Object' och har följande prototyp.

protected void finalize () throws Throwable

Finalize () -metoden åberopas när objektet samlas i sopor

Notera: Garbage collector samlar bara objekten som skapas med det nya nyckelordet. För andra objekt måste vi använda finalize () -metoden för att utföra saneringen.

Programmet nedan visar en enkel Garbage Collection i Java.

class TestGC{ @Override // finalize method: called on object once // before garbage collecting it protected void finalize() throws Throwable { System.out.println('Garbage collector called'); System.out.println('Object garbage collected : ' + this); } } class Main{ public static void main(String args()){ TestGC gc1=new TestGC(); TestGC gc2=new TestGC(); gc1 = null; //nullify gc1 System.gc(); //request for GC to run gc2 = null; //nullify gc2 Runtime.getRuntime().gc(); //request for GC to run } }

Produktion

Sopor i Java

I ovanstående program har vi skapat en klass TestGC. I den här klassen har vi åsidosatt finalize () -metoden. Sedan i huvudklassen skapar vi två objekt i TestGC-klassen. Först ogiltigförklarar vi ett objekt och ringer till System.gc () för att begära Garbage Collector.

Därefter ogiltigförklarar vi det andra objektet och anropsmetoden Runtime.getRuntime.gc () för att begära Garbage Collector. Utgången visar den slutgiltiga metodutmatningen två gånger, vilket indikerar att Garbage Collector körde två gånger.

Notera: Även om vi har den här utgången är det inte garanterat att varje gång vi får samma utdata. Det beror helt på JVM.

Hur fungerar sopuppsamling i Java?

I det här avsnittet kommer vi att se hur Garbage Collection fungerar i Java.

Under skräpsamlingen letar Garbage Collector upp Heap-minnet och “markerar” sedan de oåtkomliga föremålen. Då förstör det dem.

Men problemet uppstår när antalet objekt ökar. När objekten ökar ökar också den tid det tar för Garbage Collection när det letar efter objekt som inte kan nås. Det påverkar dock inte för mycket eftersom de flesta föremål har kort livslängd.

Uppförandet ovan kallas “Generation Garbage Collection” och ska förbättra JVM-prestanda. I detta tillvägagångssätt är hela högutrymmet uppdelat i - Young Generation, Old or Tenured Generation och Permanent Generation.

# 1) Ung Generation Heap Space: Alla nya objekt skapas i detta utrymme. När utrymmet är fullt äger Minor GC rum där alla döda föremål förstörs. Den mindre GC-processen är snabb och snabb eftersom de flesta föremål är döda. Objekten som överlever den unga generationen flyttas till de äldre generationerna.

# 2) Gamla generationens högutrymme: Denna generation lagrar föremål som överlever länge. När tröskelåldern för den unga generationen är uppfylld flyttas objektet till den gamla generationen. När det gamla generationens utrymme fylls utförs en Major GC.

Major GC är långsam eftersom objekt som är involverade här är levande objekt. Ibland rensas hela Heap-utrymmet som inkluderar både unga och gamla generationer. Detta kallas 'Full GC'.

# 3) Permanent generationL Fram till Java 7 fanns det en permanent generation (Perm Gen). Perm Gen-metadata användes av JVM. JVM använde denna metadata för att beskriva klasser och metoder som används i applikationen. Permgenen togs bort i Java 8.

Java 8 Garbage Collection: Perm Gen och Metaspace

Vi har redan nämnt om Perm Gen-utrymme som fanns fram till Java 7. Men nu i Java 8 representerar JVM klassmetadata med hjälp av det ursprungliga minnet som kallas 'Metaspace'.

Förutom Metaspace finns det en ny flagga som heter ”MaxMetaspaceSize” som begränsar minnet som används för klassmetadata. Om inget värde anges för MaxMetaspaceSize, ändrar Metaspace det vid körning enligt applikationskravet.

När klassmetadatautrymmet når MaxMetaspaceSize utlöses Metaspace GC. När det finns överdriven Metaspace GC, indikerar det minnesläckage av klasser, klassladdare etc. samt otillräcklig storlek.

Avfallssamlingsalgoritmer i Java

Det finns olika sätt på vilket Garbage Collection utförs. I det här avsnittet presenterar vi fyra sådana sätt eller algoritmer för Garbage Collection i Java.

Seriell GC

Seriell GC är den enklaste GC-algoritmen. Det fungerar främst på små högstorlekar och enkeltrådade system. Under arbetet fryser Serial GC alla applikationer.

För att aktivera Serial GC kan vi använda följande JVM-alternativ.

testfall exempel för webbapplikation
java –xx:+UseSerialGC –jar Application.java

Ovanstående kommando kan ges i kommandoraden. Här är Application.java en fil som seriell GC ska aktiveras för.

Genomströmning / parallell GC

DEN parallella GC-algoritmen är standard i JDK 8. Denna algoritm använder flera trådar för att skanna högutrymmet och komprimeringen. Denna algoritm är mest lämplig för applikationer som kan hantera trådpauser och optimera CPU-omkostnaderna.

En nackdel med parallell GC är att algoritmen pausar applikationstrådarna medan man utför mindre eller full GC.

CMS Collector

CMS står för “ Samtidig Mark Sweep ”. Denna algoritm använder sig av flera samverkande trådar för att skanna högen ( märke ) för att identifiera oanvända föremål och återvinna ( sopa ) dem. CMS-samlaren har ett läge Stop-The-World (STW).

Samlaren går i detta läge i två scenarier:

  • När objekt som tillhör den gamla generationen kan nås från statiska variabler eller trådingångspunkter. Så det här läget är på under initialiseringen av de första rotmarkeringarna.
  • När algoritmen körs samtidigt ändrar applikationen tillståndet och tvingar samlaren att gå tillbaka för att se till att rätt objekt är markerade.

CMS-samlaren kan dock drabbas av ”misslyckanden med marknadsföring”. Så vad är ett reklammisslyckande? Om föremålen från det unga generationens utrymme flyttas till den gamla generationen och samlaren inte har gjort tillräckligt med utrymme för dessa objekt i den gamla generationens högutrymme kommer ett reklamfel att inträffa.

För att förhindra reklam misslyckas kan vi ge fler bakgrundstrådar till samlaren eller ge mer högstorlek till den gamla generationen.

G1 Collector

G1 Collector är ”Garbage-First” Collector. Den är utformad för högstorlekar på mer än 4 GB. Baserat på högstorleken delar den högstorleken i regioner med storlekar från 1 MB till 32 MB.

G1-samlare markerar objekten beroende på objektens livlighet i hela högen. Efter denna märkningsfas är G1 medveten om de tomma regionerna. Således samlar den de oåtkomliga föremålen från dessa regioner, vilket frigör en stor mängd utrymme. Därför heter det som Garbage-First eftersom det samlar in regioner som innehåller sopor först.

Det uppfyller också det användardefinierade paustiden genom att använda en pausförutsägelsemodell genom att välja antalet regioner som ska samlas in beroende på det angivna paustidsmålet.

Fördel med avfallssamling

  • Garbage Collection gör minneshantering i Java effektiv eftersom det tar bort icke refererade objekt från heapminnet utan att programmeraren stör det.
  • Eftersom Garbage collection är automatisk och är en del av JVM behövs inga extra ansträngningar från programmeraren för att återvinna minnet eller förstöra objekt.
  • Programmeraren behöver inte skriva någon specifik kod för att avdela minnet och ta bort objekt som gjort i C / C ++.

Vanliga frågor

F # 1) Vilken roll har en sopor?

Svar: I Java är Garbage Collector huvudpartiet i minneshanteringen och har till uppgift att samla in de oåtkomliga föremålen och återvinna minnet.

F # 2) Vad menar du med Garbage Collection?

Svar: Garbage collection är den teknik genom vilken minne hanteras automatiskt genom att återvinna det oanvända minnet. Det är en funktion som finns i programmeringsspråk som Java, på grund av vilken programmerarna inte behöver hålla reda på de oanvända objekten och förstöra dem. Det görs automatiskt med Garbage Collection.

F # 3) Vem är ansvarig för Garbage Collection i Java?

Svar: Minneshantering av Java har ansvaret för Garbage Collection.

F # 4) Hur kan vi förhindra skräpsamling i Java?

Svar: Eftersom Garbage Collector inte återvinner minnet av variabler / objekt som lever, är det bästa sättet att förhindra Garbage Collection att fortsätta använda variabler / objekt i hela programmet.

F # 5) Hur kan du se till att ett objekt samlas upp skräp?

Svar: Ett objekt är kvalificerat för Garbage Collection när det inte kan nås, dvs när inga fler referenser hänvisar till objektet. Även om vi inte kan tvinga Garbage Collector att köra när vi vill, kan vi alltid begära att den ska köras med System.gc ().

Slutsats

Garbage Collection i Java som vi diskuterade i denna handledning är automatisk och programmeraren behöver inte bry sig om att ta bort de objekt eller variabler som tilldelats i programmet.

Automatisk skräpsamling i Java är språkets viktigaste funktion och är en del av minneshantering i Java.

Även om Garbage Collection utförs av JVM och är utom programmets räckvidd kan vi alltid begära att Garbage Collector ska köra med gc () -metoden i System- och Runtime-klass.

I denna handledning har vi diskuterat slutförandeprocessen som utförs innan objekten förstörs av Garbage Collector. Vi har också diskuterat processen för Garbage Collection i Java. Slutligen har vi diskuterat de olika algoritmer som används av Garbage Collector.

Detta kompletterar vår diskussion om Garbage Collector i Java.

=> Se upp den enkla Java-träningsserien här.

Rekommenderad läsning

^