Programacin Avanzada

Garbage Collector de Java

Hugo Axel Loza Macas

Ingeniera en Mecatrnica

Docente:
Sergio Rafael Urea Fuentes
Octubre 13, 2017

Villa de lvarez, Colima

ndice
Introduccin ................................................................................................................................................. 3
Garbage Collector (GC) de Java ............................................................................................................. 4
Clasificacin. ........................................................................................................................................... 4
Un ejemplo .............................................................................................................................................. 6
Mtodo finalize() ..................................................................................................................................... 6
Conclusin:.................................................................................................................................................. 8
Bibliografa .................................................................................................................................................. 9

2
Introduccin
Uno de los problemas mas grande de algunos lenguajes de programacin es la gestin
de memoria, en algunos lenguajes como C y C++ es necesario hacer la gestin de
memoria manual, y esto es un gran problema porque al generar demasiadas clases y
no gestionarlas de manera correcta es posible que el programa o el ordenador colapse
por exceder el ancho de memoria. El lenguaje tiene una ventaja en este tema, tiene un
proceso incluido llamado Garbage Collector(Recolector de basura) que gestiona de
manera autnoma la memoria.
La memoria est dividida en 3 secciones(la Zona de Datos, Stack y Heap)
ZONA DE DATOS : Es donde se almacenan las instrucciones del programa, las clases
con sus mtodos y constantes. Esta zona de memoria es fija, y no se puede modificar
durante el tiempo de ejecucin.
STACK: Los datos que se almacenan aqu son las referencias a objetos (instancias de
objetos) y los datos primitivos como int, float o char. Cuando ejecutamos un mtodo
con variables locales, estas se cargan en el Stack y se eliminan una vez se finaliza el
mtodo. El tamao se define durante el tiempo de compilacin y es esttico durante su
ejecucin.
HEAP: Es la zona de memoria dinmica, almacena los objetos que se crean, en un
principio tiene un tamao fijo asignado por la JVM (Java Virtual Machine), pero segn
es necesario se va aadiendo ms espacio.
Por lo que puede deducirse de las definiciones, el Stack y el Heap estn estrechamente
relacionados, ya que los objetos a los que apuntan las referencias almacenadas en el
Stack se habrn creado en el Heap. Tiene que quedar claro que la relacin referencia-
objeto es de n-1, lo que quiere decir que un objeto puede ser apuntado por muchas
referencias, pero que una referencia apunta a un solo objeto.
El Garbage Collector es un proceso encargado de liberar la memoria que no se
emplea, la magia de este recolector de basura deja asombrados a los programadores
que odian tener que gestionar la memoria ellos mismos.
Y Cmo sabe el Garbage Collector lo que puede borrar y lo que no? Es algo muy
simple, si un objeto no tiene referencias desde el Stack tiene que ser eliminado. Pero
se hablar ms a fondo sobre el funcionamiento de este proceso y sus caractersticas a
lo largo del siguiente documento porque aunque si es una gran ventaja de
programacin tambin tiene su parte negativa.

3
Garbage Collector (GC) de Java
El concepto de recoleccin de basura fue inventado por John McCarthy en 1958 para
evitar la gestin manual de memoria en el lenguaje Lisp.
Un Colector de basura (en espaol) es una aplicacin que se ejecuta dentro de la JVM
y se encarga de gestionar el Heap (montn), liberando automticamente la memoria
ocupada por aquellos objetos que no van a ser utilizados en un programa.
Entre las ventajas del uso del GCs podemos encontrar:
Se quita la responsabilidad de liberar y destruir los objetos a los programadores.
Garantiza la interoperabilidad entre distintas APIs, libreras o frameworks.
Facilita el uso de grandes cantidades de memoria.
Por contra, entre las desventajas podemos encontrar:
Consumo adicional de recursos.
Impacto en el rendimiento de aplicaciones.
Posibles paradas en la ejecucin de las aplicaciones.
Incompatibilidad con la gestin manual de la memoria.
Pero cmo la JVM sabe que objetos deben borrarse? Sencillo, si los objetos estn
perdidos en memoria, no tienen referencias, y por lo tanto no se pueden accesar, esos
son los candidatos a ser borrados, en la siguiente pasada del GC.
El GC es un proceso de baja prioridad, por lo que no se pasa en todo momento
liberando memoria, si no que pasa de vez en cuando, que podra ser en un tiempo
muerto del procesador, aunque tambin nosotros podramos sugerirle que pase, pero
va a pasar cuando pueda y quiera, un par de ejemplos de cmo mandarlo llamar son
estos.

public void pasarGarbageCollector(){

Runtime garbage = Runtime.getRuntime();

garbage.gc();

Clasificacin.
Podemos clasificar los GCs en base a sus caractersticas:

Concurrente vs Stop-The-World:

4
 Concurrentes son aquellos que pueden realizar su trabajo a la vez que se
ejecuta una aplicacin.

STW son aquellos que paran la ejecucin de la aplicacin para realizar sus
tareas de limpieza.

Paralelo vs Serie:

o Paralelos son aquellos que pueden aprovechar la existencia de mltiples

CPUs para realizar su trabajo.

o Serie son aquellos que se ejecutan en un nico hilo.

Incremental vs Monoltico:

Incrementales son aquellos dividen su trabajo en diferentes fases u

operaciones, siendo estas fases separadas en el tiempo.

Monolticos son aquellos que realizan su trabajo en una nica tarea.

Precisos vs Conservadores:

Precisos son aquellos que pueden identificar y procesar todas las referencias
de los objetos en el momento de la recoleccin.

Conservadores son aquellos que desconocen algunas de las referencias de

los objetos en el momento de la recoleccin, o que no estn seguros de si un
campo es una referencia o no.

Compactadores vs No Compactadores:

Los compactadores son aquellos que, tras realizar las tareas de limpieza
mueven los objetos, actualizando sus referencias, minimizando de esta
manera la fragmentacin de la memoria. Esta operacin implica ser STW.

Los no compactadores son aquellos que se limitan a eliminar la basura de la

memoria.

5
Un ejemplo
Vamos a analizar este cdigo lnea por lnea:

1 class MyClass {

2 public static void main(String[] args) {

3 MyClass myFirstObject = new MyClass();

4 MyClass mySecondObject = new MyClass();

5 myFirstObject = mySecondObject;

6 mySecondObject = null;

7 }

8 }

Lnea 3. Se crea el primer objeto en el heap, se crea la primera referencia en el stack, y

la referencia apunta al objeto.
Lnea 4. Se crea el segundo objeto en el heap, se crea la segunda referencia en el
stack, y la referencia apunta al objeto.
Lnea 5. La primera referencia apunta hacia el segundo objeto. En este momento el
primer objeto se queda sin referencia, es desechado por el GC, y se libera memoria.
Lnea 6. La segunda referencia, apunta a nada.

Mtodo finalize()
El otro problema que supone el paso automtico o descontrolado del Garbage Collector
es que puede eliminar un objetos con informacin que queramos guardar y que igual
se ha quedado sin referencia por culpa nuestra. Por suerte, todas las clases heredan
de Object y con ello el mtodo finalize(). Antes de que la JVM decida eliminar un
objeto perdido, ejecuta este mtodo. Gracias a ello podemos por ejemplo trabajar con
una serie de elementos, eliminar la referencia a los mismos y no preocuparnos de
guardar los datos esenciales en una base de datos (siempre que se reimplemente
finalize() en ese objeto).
La utilidad de este mtodo es que cuando el GC pasa a eliminar un objeto, la JVM
ejecuta primero el mtodo finalize() y luego el GC elimina el objeto, permitindonos por
ejemplo, hacer una copia, imprimir algn dato, o cualquier cosa que necesitemos, justo
antes de eliminarlo

6
Ejemplo:
public class MyClass {

String name;

MyClass(String name){

this.name=name;

protected void finalize(){

System.out.println(this.name);

public static void main(String[] args) {

MyClass myFirstObject=new MyClass("Ed");

MyClass mySecondObject=new MyClass("Edd");

MyClass myThirdObject=new MyClass("Eddy");

myFirstObject=null;

mySecondObject=null;

myThirdObject=null;

System.gc();

Se crean tres objetos con su respectiva referencia, luego se les da la referencia a null,
y finalmente le sugerimos al GC que pase y entonces saldra por pantalla:
Eddy

Edd

Ed

Se borra primero el ltimo objeto que se cre y que ya no tiene referencia.

Una cosa a tener en cuenta si se decide hacer esto, es que nosotros dejemos sin
referencia antes a un objeto que a otro, no implica que el Garbage Collector ejecute
antes el finalize() de ese objeto.

7
Conclusin:
El recolector de basura de java es una aplicacin incluida en el paquete principal que
facilita mucho las cosas ya que ayuda al programador a gestionar de manera optima la
memoria y evitando colapsos o sobre cargada de la memoria, y a cambio de un muy
poco uso de recursos ya que es una aplicacin de baja prioridad y que realiza el barrido
durante descansos del proceso.

Esta aplicacin ayuda mucho a la programacin ya que en otros lenguajes esta

limpieza de memoria tena que hacerse manual y requera de procesos extras que le
complicaban la escritura de cdigo al programador, el Grabage Collector es una de las
ventajas primarias del lenguaje Java y que lo diferencia por encima de otros lenguajes
de programacin.

Es de suma importancia saber el funcionamiento y como utilizarlo de manera correcta

para usar al mximo esta funcin, y adems de evitar errores o problemas generados
por un mal uso, es por eso que este trabajo ofreci una amplia explicacin sobre cmo
es esta funcin, que es lo que realmente haces y como lo hace, adems de algunos
ejemplos bsicos para ver su funcionamiento.

8
Bibliografa

[1] finxnif, Las nuevas tecnologias y yo, 08 Agosto 2011. [En lnea]. Available:
https://ayddup.wordpress.com/2011/08/08/la-memoria-en-java-garbage-collector-y-el-metodo-
finalize/.

[2] SrPoderLog, 9 Octubre 2008. [En lnea]. Available:

https://srpoder.wordpress.com/2008/10/09/memoria-y-garbage-collection-en-java/.

[3] J. L. R. Villapecelln, Adictos Al Trabajo, 2 junio 2015. [En lnea]. Available:

https://www.adictosaltrabajo.com/tutoriales/garbage-collector/.

[4] Wikipedia , Wikipedia, 1 mayo 2017. [En lnea]. Available: 1.

https://es.wikipedia.org/wiki/Recolector_de_basura.