style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Recolector de Basura de Java

Hola buen día me encuentro estudiando para mi examen de certificación, pero me he atorado en los ejercicios que encontré del recolector de basura, tengo las siguientes clases:

interface Animal { void makeNoise(); }
class Horse implements Animal {
Long weight = 1200L;
public void makeNoise() { System.out.println("whin"); }
}
public class Ice extends Horse {
public void makeNoise() { System.out.println("vin"); }
public static void main(String[] args) {
Ice i1 = new Ice();
Ice i2 = new Ice();
Ice i3 = new Ice();
i3 = i1; i1 = i2; i2 = null; i3 = i1;
}
}

Y me pregunta cuantos objetos son candidatos en el recolector de basura, en la respuesta dice que son 4, pero no entiendo el porque si solo se crean 3, espero y me puedan ayudar.

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

Te dice que 4 y no te explica

¡¿Te dice que 4 y no te explica porque?! ¿Pues de donde estas estudiando?

Reformateando tu código ( usa el tag <code> y </code> ) tenemos lo siguiente:

  1. interface Animal {
  2.    void makeNoise();
  3.  }
  4. class Horse implements Animal {
  5.     Long weight = 1200L;
  6.     public void makeNoise() {
  7.        System.out.println("whin");
  8.     }
  9. }
  10. public class Ice extends Horse {
  11.      public void makeNoise() {
  12.          System.out.println("vin");
  13.      }
  14.      public static void main(String[] args) {
  15.           Ice i1 = new Ice();
  16.           Ice i2 = new Ice();
  17.           Ice i3 = new Ice();
  18.           i3 = i1;
  19.           i1 = i2;
  20.           i2 = null;
  21.           i3 = i1;
  22.      }
  23. }

- En las lineas 15-17 se crean 3 objetos que, como tienen un dato compuesto ( weight de la clase Horse ) suman 6 objetos creados. Por cierto esta pregunta tiene truco porque si el valor de weight fuera > -129 y < 128 serían solamente 4 objetos ( tres instancias y todas compartirían el valor del peso por el pool de objetos que tiene el autoboxing que es de 255 elementos ).

- Luego en la linea 18 a i3 se le asigna el valor de i1 porlo que la a lo que apuntaba queda sin referencia y por lo tanto suceptible de ser gc'ed.

- En la linea 19 a i1 se le asigna el valor de i2, pero nadie se queda sin referencia ( i3 tiene lo que originalmente tenía i1 ) así que no pasa nada.

- En la linea 20 a i2 se le asigna el valor null, pero como i1 ya tenía ese valor tampoco pasa nada.

- Finalmente en la linea 21 a i3 se le asigna el valor de i1 ( que orignalmente era el de i2) por lo tanto i3 "tira" la referencia original de i3 con lo que suman 2 los objetos que ya no tienen valor de referencia en el main.

Como estos 2 tienen otros dos objetos ( el weight de cada uno ) entonces son 4 los objetos que pueden ser gc'eados.

Sin embargo en la linea 22 son los 6 objetos pueden ser marcados para ser recolectados.

Pero no te preocupes, en el exámen de certificación no se hacen preguntas con truco. No es el objetivo saber si estás poniendo atención a estos detallitos. El objetivo es que sepas como funcionan las cosas no que "encuentres las 5 diferencias"

Si de donde estas estudiando no te explica todo esto y además tiene el formato que pusiste originalmente te recomiendo que cambies de fuente de información.

Imagen de ezamudio

weight es el cuarto

Oscar, ora sí te pasaste de rollero...

El cuarto objeto que se puede ir al diablo es el Long weight. Es un Long o sea un objeto, pero se inicializa usando un long nativo. Se hace autoboxing pero es similar a la internalización de los Strings (todas las veces que uses la cadena "whin" en tu código, se va a usar exactamente la misma instancia, igual pasa con ese Long que termina asignado a weight).

Se van a la goma las tres instancias de Ice y como el weight de cada una apunta a la misma instancia de un Long que ya ninguna usa, se va a la goma ese también, por eso se liberan 4 objetos.

EDIT: Pero a fin de cuentas Oscar tiene razón. Por leer al aventón creí que los tres Ice se apuntaban a null al final. Bueno, si hubiera estado en examen, hubiera contestado bien, aunque por la razón equivocada, probando así que esos exámenes de certificación no sirven para nada.

En si, si viene enumerado el

En si, si viene enumerado el código, lo que no viene es explicado solo te da las respuestas

Cada weight vale por uno.

Ja jaja . Si, yo me imagino que la cantidad de veces que tuve bien una respuesta en la universidad por la razón equivocada fue alta.

En resumen: 2 se van al diablo y cada uno tiene un "weight" diferente da un total de 4

El exámen de certificación de Java NO es nada como esto, nunca te ponen preguntas de truco ( ni mezclan varios conceptos en la misma pregunta ) .

El lugar de donde esta sacando la info sakura tiene fallas eso es todo, pero el exámen es mucho más serio, no hay que demeritarlo por esto.

Como ejemplo de lo del weight va un ejemplo:

$ cat AutoBoxingWrapperPoolDemo.java
class AutoBoxingWrapperPoolDemo {
  public static void main( String ... args ) {
    Long a = 1024L;
    Long b = 1024L;
    Long c = 127L;
    Long d = 127L;
    System.out.println( a == b );
    System.out.println( c == d );
  }
}

$ javac AutoBoxingWrapperPoolDemo.java

$ java AutoBoxingWrapperPoolDemo
false
true

Imagen de ezamudio

ah caray

y por qué a==b pero c!=d? hmmmmm.... #EsTanMalProgramador que no entiende que pedo.

Más bien assert a != b && c

Más bien assert a != b && c == d;

Con el autoboxing en Java 1.5 se agregó el método Wrapper.valueOf y se puso un pool interno para los valores, pero como no es factible tenerlos para todos, se decidió que fuera un pool de 255 elementos ( del -128 al 127 )

Entonces cuando se escribe:

Long a = 1024L;

Al autoboxing hace algo como esto desde la compilación:

Long a = Long.valueOf( 1024L );

Y ese método regresa el valor en el caché si lo tiene ( -128 a 127 ) y si no crea uno nuevo.

Es por ello que:

Long a = 1024L;
Long b = 1024L;

Crea dos objetos diferentes que dan false cuando se les aplica == y

Long c = 127L;
Long d = 127L;

Representan el mismo objeto ( con la misma referencia ) y por lo tanto dan true en ==.

Imagen de ezamudio

íralo

Nooooo dice, se nota que alguien ha estado estudiando los mecanismos internos de la JVM, será porque están haciendo un lenguaje...

:)

Imagen de greeneyed

En cuanto al examen...

Sera que ahora lo han cambiado, pero cuando yo lo estuve mirando, no sólo tenía truco si no que incluso en algunas preguntas parecía que te examinaran de entender inglés en todos sus matices, por que el truco estaba en como te lo decían exactamente....

Widening || Autoboxing

Encontre algo curioso con el widening (que tiene que ver algo con el autoboxing tambien) aqui

Bueno eso sí, como se intenta

Bueno eso sí, como se intenta que la redacción sea no ambigua, el inglés se ejercita bastante y para nosotros los no angloparlantes se vuelve una barrera.

Hola Oscar, te quería

Hola Oscar, te quería comentar que he estado hace un par de horas leyendo tu entrada sobre el recolector de basura de Java porque no sabía muy bien como funcionaba, te quería hacer una pregunta porque precisamente me he encontrado en el simulador la misma pregunta ahora hace un momento, según he entendido en tu explicación tu comentas los objetos que pueden ir al recolector de basura son 4 y una vez que se termina de leer el metodo main son 6. Entonces ¿por que en el simulador me sale que son 4? Te adjunto una impresión de pantalla del código.

Si me lo pudieras explicar por favor, no me queda del todo claro esto. Gracias de antemano y un saludo

http://s3.subirimagenes.com:81/otros/8090843duda.jpg

Ujule pues ni yo mismo me

Ujule pues ni yo mismo me acuerdo... a ver (leyendo)

Ah claro.

Cada instancia de Ice tiene el atributo weight que por ser un Long es un objeto.

Luego entonces, cada vez que creas una instancia de Ice estás creando dos objetos.

Ice i1 = new Ice(); // uno por ice otro por weight  = 2

Y cada vez que se pierde la referencia se vuelven candidatos al gc.

...
i3 = i1; // lo que tenía i3 queda sin referencia y puede ser gc'ed, como son 2 pues son dos objetos

Esto sucede dos veces en el código.

Como se hacen tres llamadas se crean 6 objetos en total ( 3 x 2 = 6 ).

El en código se pierden dos referencias se "podría" decir que coincide con la respuesta del simulador ( 2 x 2 = 4 objetos candidatos )

Pero al terminar el main, el tercer objeto tambien se pierde por lo que son 6.

¿Por que el simulador dice que son 4? Por que lo escribió un humano, lo quiso hacer "difícil" y en la complicación cometió un error ( de ambigüedad en todo caso, no sé si la pregunta dice "cuantos son elegibles en la linea 15 ) en vez de poner un ejemplo más útil como por ejemplo el de conservar una referencia en un arreglo ( más adelante un post sobre esto )

En punto es que entiendas cuando un objeto puede ser elegible para ser colectado y el exámen no tiene este tipo de preguntas.

Muchas gracias Oscar me quedó

Muchas gracias Oscar me quedó ahora más claro. Gracias de nuevo por tu rápida respuesta, me sirvió de mucha ayuda.

@Neodesk Si.. de nada :) El

@Neodesk Si.. de nada :)

El exámen de certificación no hace preguntas con truco, pero si requiere que entiendas el concepto claramente.

Escribí este post al respecto. Espero que sea de ayuda

El garbage collector y los memory leaks

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">