Menú

Què és la recollida d'escombraries a Java i com funciona

  • Principal
  • Altres
  • Què és la recollida d'escombraries a Java i com funciona

what is garbage collection java

Proveu El Nostre Instrument Per Eliminar Problemes

Aquest tutorial explica què és Garbage Collection a Java i com funciona Garbage Collector. També coneixereu els algorismes per a la recollida d’escombraries:

Els lectors que tinguin coneixements de C / C ++ han de ser conscients que és responsabilitat del programador crear i suprimir els objectes de C / C ++.

Es produeixen greus errors si el programador s’oblida de destruir els objectes creats. Això es deu al fet que no destruir els objectes pot provocar ' Sense memòria ”Errors, fuites de memòria, etc.

Aquesta situació es compleix completament a Java, ja que no cal que un programador faci un seguiment dels objectes. Java s’encarrega de la destrucció d’objectes mitjançant la recollida automàtica d’escombraries.

=> Visiteu aquí per aprendre Java des de zero.

Recollida d

El procés mitjançant el qual els objectes que ja no s’utilitzen s’eliminen de la memòria acumulativa s’anomena “recollida de deixalles”. La tècnica de recollida d’escombraries forma part de la gestió de memòria a Java.

Així, a Java, Garbage Collector destrueix tots els objectes que ja no s’utilitzen.

Què aprendreu:

Què és un col·leccionista d'escombraries a Java?

Garbage Collection a Java està gestionat per un programa anomenat Garbage Collector.

Garbage Collector es pot definir com un programa que s’utilitza per gestionar la memòria automàticament gestionant la desassignació de l’objecte.

Sabem que en el llenguatge Java, els nous objectes es creen i s’assigna memòria mitjançant el nou operador. La memòria assignada a un objecte que utilitza un nou operador es manté assignada fins que les referències utilitzen aquest objecte.

Tan bon punt deixen d’existir les referències, es recupera la memòria que ocupa l’objecte. Aleshores, Java gestiona la desassignació o la destrucció d’objectes automàticament i no hem de destruir explícitament l’objecte.

Aquesta tècnica és la tècnica de recollida d’escombraries a Java, on els programadors no necessiten gestionar explícitament la desassignació d’objectes.

Tingueu en compte que si els programes no desassignen la memòria quan els objectes no la necessiten, finalment no quedarà memòria per assignar i els programes es bloquejaran. Aquesta situació s’anomena fuga de memòria.

El recollidor d'escombraries sempre s'executa en segon pla sobre un fil de dimoni. Es considera Garbage Collector com el millor exemple del fil del dimoni.

Garbage Collector s'executa amb la intenció d'alliberar la memòria dinàmica. Ho fa destruint els objectes 'inabastables'.

Què és un objecte 'inabastable'?

Un objecte no es pot arribar quan no hi ha ni una sola referència associada.

Penseu en el següent fragment de codi:

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

Com es veu al codi anterior, es pot arribar a un objecte sempre que s’hi associï una referència. En el moment que s'elimina l'associació de referència (una referència de configuració a nul en el cas anterior) l'objecte no es pot arribar.

Quan no es pot arribar a un objecte, es pot elegir per recollir escombraries (GC).

Com podem fer que un objecte sigui apte per a GC?

Tot i que el programador no està obligat a destruir els objectes ja que GC els fa càrrec, almenys el programador pot fer que aquests objectes no siguin accessibles quan ja no siguin necessaris.

Fent això, GC recopilarà els objectes inabastables i els destruirà.

Hi ha algunes maneres de fer que un objecte sigui apte per a GC fent-lo inaccessible.

Ells són:

# 1) Anul·leu la referència

Donada una referència assignada a un objecte, si aquest objecte ja no és necessari, assigneu la referència a nul.

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

Quan s estableix com a nul, l'objecte Student no es pot accedir.

# 2) Reassigneu la referència

Aquesta és una altra manera de fer que els objectes siguin elegibles per a GC.

Penseu en el codi següent.

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

Ara, ja que hem assignat s1 a un altre objecte, es desferencia l'objecte Student a què fa referència s1.

# 3) Creeu un objecte anònim

En crear un objecte anònim, podem fer que els objectes siguin elegibles per a GC.

Podem crear un objecte anònim com es mostra a continuació:

new Student();

Un cop fem que els objectes siguin elegibles per a GC, aquests objectes poden ser o no destruïts immediatament per GC. Això es deu al fet que no podem obligar explícitament el GC a executar-lo quan i quan vulguem.

Quan funciona el recol·lector de deixalles?

Correspon a la JVM executar el programa Recollidor de deixalles. Quan JVM executa Garbage Collector, els objectes inaccessibles es destrueixen. Tot i això, no podem garantir quan s’executarà la JVM.

Tot i que no podem obligar el GC a executar-se, podem sol·licitar una recollida d’escombraries.

Es pot sol·licitar el GC mitjançant qualsevol dels mètodes següents.

# 1) System.gc (): La classe System de Java proporciona un mètode estàtic gc () mitjançant el qual podem sol·licitar a la JVM que executi Garbage Collector.

# 2) Runtime.getRuntime (). Gc (): Igual que System.gc (), també podem utilitzar el mètode gc () de 'Classe d'execució' per sol·licitar a JVM que executi Garbage Collector.

Nota: No hi ha cap garantia que el recol·lector de deixalles s’executarà després d’una sol·licitud d’aquests dos mètodes.

Finalització

La finalització la realitza Garbage Collector just abans de destruir els objectes. Com a part de la tècnica de finalització, Garbage Collector crida el mètode finalize () a l'objecte. El mètode finalize () s’utilitza per realitzar activitats de neteja.

El mètode finalize () és proporcionat per la classe 'Object' i té el prototip següent.

protected void finalize () throws Throwable

El mètode finalize () s'invoca sempre que l'objecte és recollit a la brossa

Nota: El col·lector de deixalles només recull els objectes que es creen mitjançant la nova paraula clau. Per a altres objectes, hem d’utilitzar el mètode finalize () per realitzar la neteja.

El programa següent mostra una senzilla col·lecció de deixalles a 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 } }

Sortida

Recollidor d

Al programa anterior, hem creat una classe TestGC. En aquesta classe, hem substituït el mètode finalize (). Després, a la classe principal, creem dos objectes de la classe TestGC. En primer lloc, anul·lem un objecte i cridem a System.gc () per sol·licitar el col·lector de deixalles.

A continuació, anul·larem el segon objecte i el mètode de trucada Runtime.getRuntime.gc () per sol·licitar Garbage Collector. La sortida mostra la sortida del mètode de finalització dues vegades, cosa que indica que el recol·lector de deixalles va funcionar dues vegades.

Nota: Tot i que tenim aquesta sortida, no es garanteix que cada vegada obtinguem la mateixa sortida. Depèn completament de JVM.

Com funciona la recollida d'escombraries a Java?

En aquesta secció, veurem com funciona Garbage Collection a Java.

Durant la recollida d'escombraries, el recol·lector de deixalles busca la memòria Heap i després 'marca' els objectes inaccessibles. Després els destrueix.

Però el problema sorgeix quan augmenta el nombre d’objectes. A mesura que augmenten els objectes, també augmenta el temps que es triga a recollir escombraries a mesura que busca objectes inaccessibles. Tot i això, no afecta massa, ja que la majoria dels objectes tenen una vida útil curta.

Es diu el comportament anterior 'Recollida d'escombraries generacional' i se suposa que millora el rendiment de la JVM. En aquest enfocament, tot l’espai Heap es divideix en: generació jove, generació vella o permanent i generació permanent.

# 1) Espai munt de generació jove: Tots els objectes nous es creen en aquest espai. Una vegada que l'espai és ple, es produeix un GC menor on es destrueixen tots els objectes morts. El procés GC menor és ràpid i ràpid, ja que la majoria dels objectes estan morts. Els objectes que sobreviuen a la jove generació es traslladen a les generacions més grans.

# 2) Espai de muntatge de la vella generació: Aquesta generació emmagatzema objectes que sobreviuen molt de temps. Quan es compleix l'edat llindar establerta per a la generació jove, l'objecte es trasllada a la generació antiga. Quan s'omple l'espai de la vella generació, es realitza un GC major.

El GC major és lent ja que els objectes implicats aquí són objectes vius. De vegades, s’esborra tot l’espai Heap que inclou generacions joves i velles. Això s'anomena 'Full GC'.

# 3) Generació permanent L Fins a Java 7 hi havia una generació permanent (Perm Gen). JVM va utilitzar les metadades de Perm Gen. JVM va utilitzar aquestes metadades per descriure classes i mètodes utilitzats a l'aplicació. El Perm Gen es va eliminar a Java 8.

Java 8 Garbage Collection: Perm Gen i Metaspace

Ja hem esmentat sobre l’espai Perm Gen que hi havia fins al Java 7. Tanmateix, ara a Java 8, la JVM representa les metadades de classe mitjançant la memòria nativa anomenada “Metaspace”.

A part de Metaspace, hi ha una nova marca anomenada 'MaxMetaspaceSize' que limita la memòria utilitzada per a les metadades de classe. Si no s’especifica cap valor per a MaxMetaspaceSize, Metaspace el canvia de mida en temps d’execució segons la demanda de l’aplicació.

Quan l’espai de metadades de classe arriba a MaxMetaspaceSize, s’activa el Metaspace GC. Quan hi ha un GC Metaspace excessiu, indica pèrdues de memòria de classes, carregadors de classes, etc., així com un dimensionament inadequat.

Algorismes de recollida d'escombraries a Java

Hi ha diverses maneres en què es realitza la recollida d’escombraries. En aquesta secció, presentarem quatre maneres o algorismes per a la recollida de deixalles a Java.

GC de sèrie

El GC en sèrie és l'algorisme GC més senzill. Funciona principalment en mides de munts petits i sistemes de rosca simple. Mentre treballa, Serial GC congela totes les aplicacions.

Per activar Serial GC, podem utilitzar la següent opció JVM.

optimitzador de sistema gratuït per a Windows 7
java –xx:+UseSerialGC –jar Application.java

L'ordre anterior es pot donar a la línia d'ordres. Aquí Application.java és un fitxer per al qual s’ha d’habilitar el GC de sèrie.

Rendiment / GC paral·lel

L'algorisme GC paral·lel és el predeterminat a JDK 8. Aquest algorisme utilitza múltiples fils per escanejar l'espai de la pila i la compactació. Aquest algorisme és adequat sobretot per a aplicacions que poden gestionar pauses de fils i optimitzar la sobrecàrrega de la CPU.

Un desavantatge del GC paral·lel és que mentre es realitza un GC menor o complet, l'algoritme posa en pausa els fils de l'aplicació.

El col·leccionista CMS

El CMS significa ' Marc escombrat simultani ”. Aquest algorisme fa ús de múltiples concurrents fils per escanejar el munt ( senyal ) per identificar objectes no utilitzats i reciclar ( escombrar ) ells. El col·lector CMS té un mode Stop-The-World (STW).

El col·leccionista passa en aquest mode en dos escenaris:

  • Quan es pot arribar a objectes pertanyents a la vella generació des de variables estàtiques o punts d’entrada de fil. Per tant, aquest mode està activat durant la inicialització de les marques arrel inicials.
  • Quan l'algorisme s'executa simultàniament, l'aplicació canvia l'estat i obliga el col·lector a tornar enrere per assegurar-se que els objectes correctes estan marcats.

Tanmateix, el col·leccionista CMS pot patir 'errors de promoció'. Què significa, doncs, un fracàs promocional? Si els objectes de l'espai de generació jove es traslladen a la generació anterior i el col·leccionista no ha fet prou espai per a aquests objectes a l'espai d'emmagatzematge de generació anterior, es produirà un error promocional.

Per evitar fallades promocionals, podem proporcionar més fils de fons al col·leccionista o proporcionar més mida de pila a la generació anterior.

El col·leccionista G1

El col·leccionista G1 és el col·leccionista 'Primer escombraries'. Està dissenyat per a mides de pila de més de 4 GB. Segons la mida de l'emmagatzematge dinàmic, divideix la mida de l'emmagatzematge en regions de mides que van des d'1 MB fins a 32 MB.

El col·lector G1 marca els objectes en funció de la vivacitat dels objectes a tot el munt. Després d'aquesta fase de marcatge, G1 és conscient de les regions buides. Així, recull els objectes inabastables d’aquestes regions, alliberant així una gran quantitat d’espai. Per tant, s’anomena Garbage-First, ja que recull primer regions que contenen escombraries.

També compleix l'objectiu de temps de pausa definit per l'usuari mitjançant un model de predicció de pausa seleccionant el nombre de regions a recollir en funció de l'objectiu de temps de pausa especificat.

Avantatge de recollir escombraries

  • Garbage Collection fa que la gestió de la memòria a Java sigui eficient, ja que elimina objectes no referenciats de la memòria dinàmica sense la interferència del programador.
  • Com que la recollida d'escombraries és automàtica i forma part de JVM, el programador no necessita cap esforç addicional per recuperar memòria o destruir objectes.
  • El programador no necessita escriure cap codi específic per desassignar la memòria i suprimir objectes tal com es fa a C / C ++.

Preguntes freqüents

P # 1) Quin és el paper d'un col·leccionista d'escombraries?

Resposta: A Java, Garbage Collector és la principal part de la gestió de la memòria i té la tasca de recollir els objectes inaccessibles i recuperar la memòria.

Q # 2) Què vol dir amb recollida d'escombraries?

Resposta: La recollida d’escombraries és la tècnica per la qual la memòria es gestiona automàticament recuperant la memòria no utilitzada. És una característica present en llenguatges de programació com Java, a causa de la qual els programadors no necessiten fer un seguiment dels objectes no utilitzats i destruir-los. Es fa automàticament mitjançant recollida d'escombraries.

Q # 3) Qui és el responsable de la recollida d'escombraries a Java?

Resposta: La gestió de la memòria de Java té la responsabilitat de Garbage Collection.

Q # 4) Com podem evitar la recollida d'escombraries a Java?

Resposta: Com que Garbage Collector no recupera la memòria de variables / objectes que estan vius, la millor manera d’evitar que Garbage Collection sigui continuant utilitzant variables / objectes durant tot el programa.

Q # 5) Com es pot assegurar que un objecte es reculli?

Resposta: Un objecte és apte per a la recollida d’escombraries quan no s’hi pot accedir, és a dir, quan no es fan més referències a l’objecte. Tot i que no podem obligar el recol·lector de deixalles a executar-se sempre que vulguem, sempre podem sol·licitar-lo que s’executi mitjançant System.gc ().

Conclusió

La col·lecció de deixalles a Java que hem comentat en aquest tutorial és automàtica i el programador no ha de preocupar-se per suprimir els objectes o variables assignats al programa.

La recollida automàtica d’escombraries a Java és la característica més important del llenguatge i forma part de la gestió de memòria a Java.

Tot i que JVM fa Garbage Collection i està fora de l'abast del programador, sempre podem demanar al Garbage Collector que s'executi mitjançant el mètode gc () de la classe System i Runtime.

En aquest tutorial, hem parlat del procés de finalització que es realitza abans que Garbage Collector destrueixi els objectes. També hem debatut sobre el procés de recollida d’escombraries a Java. Finalment, hem debatut sobre els diversos algoritmes utilitzats pel col·lector de deixalles.

Això completa la nostra discussió sobre Garbage Collector a Java.

=> Mireu aquí les sèries de formació Java senzilles.

Lectura recomanada

^