Versión Diciembre 2001

SECCION 3
Recolector de basura –Garbage Collector-.........................2
Objetivo 1............................................................................................................................2
¿Por qué querrías utilizar el recolector de basura?.........................................................2
Java y el recolector de basura.........................................................................................2
1. Recolector de basura –Garbage Collector-
Objetivo 1.
Exponer el comportamiento que es garantizado por el sistema de recolección de basura y
escribir código que explícitamente haga objetos elegibles para la recolección.

¿Por qué querrías utilizar el recolector de basura?

Puedes ser un programador Java muy experimentado y todavía no haber tenido nunca que
familiarizarse con los detalles del recolector de basura. Incluso la expresión recolección de
basura es un poco rara. En este contexto significa la liberación de memoria que se ha
asignado y ha sido usada por el programa. Cuando memoria asignada ya no se necesita
puede considerarse como basura, es decir algo que ya no se necesita; y que simplemente
está desordenando espacio útil.

Una de las grandes bellezas aclamadas de Java es que no tienes que preocuparse por la
recolección de basura. Si vienes de programar con Visual Basic puede parecerte absurdo
que algún sistema no cuide este detalle por si mismo. En C/C++ el programador tiene que
seguir, de forma manual, el rastro de la asignación y desasignación de la memoria. Como
resultado las "fugas de memoria" son una gran fuente de errores difíciles de rastrear. Ésta
es una de las razones por las que con algunas versiones de aplicaciones de Microsoft como
Word o Excel, apenas comienzan a ejecutarse se detienen. Las fugas de memoria a la larga,
finalmente hacen que el sistema entero se cuelgue y que te veas en la necesidad de pulsar
ese gran interruptor luminoso. En alguna parte, en esas centenares de miles de líneas de
código en C++, un programador asignó un bloque de memoria pero se le olvido asegurarse
de liberarla.

Java y el recolector de basura.

A diferencia de C/C++, Java libera automáticamente las referencias que no se están

utilizando. No tienes que pasar por el trauma de buscar asignaciones de memoria que nunca
son liberadas y por consiguiente, no necesita saber como asignar ó como saber el tamaño de
un tipo de datos para asegurar la compatibilidad de la plataforma. Así qué ¿Por qué querrías
conocer mas los detalles del recolector de basura? Dos respuestas saltan a mi mente, una es
pasar el examen y la otra es comprender lo que ocurre en circunstancias extremas.

Si escribes código que genere números muy grandes de objetos o de variables te puede ser
útil saber cuando se liberan las referencias.
Si lees algún newsgroups verás a personas informando en ocasiones de ciertas aplicaciones
Java que agotan los recursos y hacen que todo se caiga. Esto no estaba en el folleto del
SUN cuando lanzaron Java.
Siguiendo la filosofía de la recolección de basura automática, puedes sugerir o animar que
la JVM realice la recolección de basura, pero no la puedes forzar.

Permíteme remarcar el punto, no puedes forzar la ejecución de la recolección de

basura, sólo puedes sugerirla.

A primera vista el termino finalización me suena un poco como a los destructores en C++
usados para limpiar los recursos antes de que un objeto se destruya. La diferencia es qué en
Java los recursos internos no necesitan ser liberados durante la finalización porque el
recolector de basura cuida la asignación de memoria. Sin embargo si tienes recursos
externos como un archivo de información, puedes usar la finalización para liberarlos.

Escribir ejercicios o practicar con el recolector de basura es un poco complejo ya que no

hay manera de conseguir código que indique cuando está disponible para la recolección de
basura. No puedes escribir un fragmento de código con una sintaxis como la siguiente:

if(EligibleForGC(Object){ //código no real

System.out("Ready for Garbage");
}

Debido a esto solo tienes que aprender las reglas.

Una vez que una variable no es referenciada en mucho tiempo está disponible para ser
recolectada por el recolector de basura.

Puedes sugerir la ejecución del recolector de basura con el método System.gc(), pero esto
no garantiza que se ejecutará inmediatamente.

Las variables locales en los métodos pierden su alcance cuando el método que las ocupa
termina. A partir de ese momento esos métodos son elegibles para el recolector de basura.
Cada vez que el método vuelve a estar en el alcance del programa las variables locales se
vuelven a crear.

Pregunta 1)

¿Cual de las siguientes líneas tiene la sintaxis correcta para sugerir que la JVM ejecute la
recolección de basura?
1) System.free();
2) System.setGarbageCollection();
3) System.out.gc();
4) System.gc();

Pregunta 2)

¿Qué código puedes escribir para asegurarte que las variables tipo int son recolectadas en
un punto particular en este código?

public class Rub{

int i=1;
int j=2;
int k=3;
public static void main(String argv[]){
Rub r = new Rub();
r.amethod();
}
public void amethod(){
i=0;
j=0;
k=0;
}
}

1) System.gc();
2) System.free();
3) Fijar el valor de cada variable int a null.
4) Ninguno de los anteriores.

Respuestas

Respuesta 1)

4) System.gc();

Respuesta 2)

4) Ninguno de los anteriores.

Únicamente puedes sugerir la ejecución del recolector de basura, por consiguiente no

puedes estar seguro que se ejecutará en algún punto en particular de tu código.
Otras Fuentes para este tema
Jyothi Krishnan en
http://www.geocities.com/SiliconValley/Network/3693/obj_sec3.html#obj8