"¡Hola de nuevo!"
"Ahora les voy a hablar de otra cosa maravillosa: WeakReference ".
"Se ve casi igual que SoftReference:"
// Create a Cat object
Cat cat = new Cat();
// Create a weak reference to a Cat object
WeakReference<Cat> catRef = new WeakReference<Cat>(cat);
// Now only the catRef weak reference points at the object
cat = null;
// Now the ordinary cat variable also references the object
cat = catRef.get();
// Clear the weak reference
catRef.clear();"Una referencia débil tiene otra característica especial".
"Si un objeto no tiene referencias ordinarias o referencias blandas, sino solo referencias débiles, entonces el objeto está vivo, pero se destruirá en la próxima recolección de basura".
"¿Puedes decir eso otra vez? ¿Cuál es la diferencia entre estas referencias?"
"Un objeto protegido de la muerte solo por SoftReference puede sobrevivir a tantas recolecciones de basura como desee y probablemente será destruido si no hay memoria suficiente".
"Un objeto que se mantiene alejado de la muerte solo por una WeakReference no sobrevivirá a la próxima recolección de basura. Pero hasta que eso suceda, puede obtener el objeto llamando al método get () en WeakReference y luego llamar a sus métodos o hacer otra cosa con él ."
"¿Qué pasa si el objeto es referenciado tanto por SoftReference como por WeakReference?"
"Eso es simple. Si al menos una referencia regular apunta a un objeto, se considera vivo. Por cierto, esa referencia se llama StrongReference".
"Si no hay referencias regulares que apunten a un objeto, pero una SoftReference sí lo hace, entonces es fácilmente accesible".
"Si no hay referencias regulares o SoftReferences que apunten a un objeto, pero una WeakReference sí lo hace, entonces es débilmente alcanzable".
"Piénselo. Una SoftReference protege el objeto para que no se elimine y garantiza que el objeto se elimine solo si no hay suficiente memoria. Una WeakReference retiene el objeto hasta la próxima recolección de elementos no utilizados. Una SoftReference ofrece una mayor resistencia a la eliminación".
"Ah. Creo que entiendo."
"Genial, luego te contaré sobre otra cosa interesante relacionada con WeakReferences: el WeakHashMap".
"¡Suena serio!"
"¡Y algo más! Un WeakHashMap es un HashMap cuyas claves son referencias débiles (WeakReferences)".
"Es decir, agregas objetos a un HashMap de este tipo y trabajas con ellos. Lo de siempre".
"Mientras los objetos que almacene en un WeakHashMap tengan referencias regulares (fuertes o blandas) como claves, estos objetos estarán vivos".
"Pero supongamos que no hay más referencias a estos objetos en toda la aplicación. Todo lo que evita que mueran son algunas WeakReferences dentro de WeakHashMap. Después de la siguiente recolección de basura, tales objetos desaparecerán de WeakHashMap. Por sí mismos. Como si nunca estuvieron allí".
"No estoy seguro de haber entendido".
"Almacena pares de objetos en un WeakHashMap: una clave y un valor. Pero el WeakHashMap no hace referencia a las claves directamente, sino a través de WeakReferences. Por lo tanto, cuando los objetos utilizados como claves se vuelven débilmente accesibles, se destruyen en el siguiente recolección de basura Y como resultado, sus valores también se eliminan automáticamente del WeakHashMap ".
"Es muy conveniente usar un WeakHashMap para almacenar información adicional sobre ciertos objetos".
"En primer lugar, acceder a la información es muy fácil si usa el objeto como clave".
"En segundo lugar, si el objeto se destruye, desaparece del HashMap junto con todos los datos asociados".
"Por ejemplo:
// Create an object to store additional information about the user
WeakHashMap<User, StatisticInfo> userStatistics = new WeakHashMap<User, StatisticInfo>();
// Put information about the user into userStatistics
User user = session.getUser();
userStatistics.put(user, new StatisticInfo (…));
// Get information about the user from userStatistics
User user = session.getUser();
StatisticInfo statistics = userStatistics.get(user);
// Remove any information about the user from userStatistics
User user = session.getUser();
userStatistics.remove(user);- "Dentro de un WeakHashMap, las claves se almacenan como WeakReferences".
- "Tan pronto como el recolector de basura destruye el objeto de usuario, se llama implícitamente al método remove (usuario) dentro de WeakHashMap y cualquier información asociada con el objeto de usuario se elimina de WeakHashMap automáticamente".
"Parece una herramienta poderosa. ¿Dónde puedo usarla?"
"Eso depende de las circunstancias. Digamos que tiene un hilo en el programa que rastrea el trabajo de algunas tareas, representadas por objetos, y escribe información sobre ellas en un registro. Este hilo podría almacenar los objetos monitoreados en un WeakHashMap. Tan pronto como como los objetos no son necesarios, el recolector de basura los elimina y las referencias a ellos también se eliminan automáticamente del WeakHashMap".
"Suena interesante. Siento que todavía no he escrito ningún programa Java serio que aproveche mecanismos tan poderosos. Pero trabajaré para lograrlo. Muchas gracias, Ellie, por una lección tan interesante".
GO TO FULL VERSION