example - java.util.locale spanish

Usando el ReferenceQueue de Java

Question

¿ SoftReference y WeakReference realmente solo ayudan cuando se crean como variables de instancia? ¿Hay algún beneficio al usarlos en el alcance del método?

La otra parte importante es ReferenceQueue . Además de poder rastrear qué referencias se determinan como basura, ¿se puede usar Reference.enqueue() para registrar por la fuerza un objeto para la recolección de basura?

Por ejemplo, ¿valdría la pena crear un método que tome algunos recursos de memoria pesados ​​(mantenidos por referencias fuertes) en un objeto y creando Referencias para ponerlos en cola?

Object bigObject;
public void dispose() {
    ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
    WeakReference<Object> ref = new WeakReference<Object>(bigObject, queue);
    bigObject = null;
    ref.enqueue();
}

(Imagina que el Objeto en este caso representa un tipo de objeto que usa mucha memoria ... como BufferedImage o algo así)

¿Esto tiene algún efecto realista? ¿O es solo una pérdida de código?

Answer 1

No estoy seguro de cuál es la pregunta aquí, pero:

1) ref. Suave trate de mantener la referencia hasta que jvm realmente necesite la memoria. Ideal para cachés, especialmente los de LRU. Mira muchos ejemplos en guayaba.

2) la referencia débil no intenta evitar que gc libere el objeto en absoluto. Se utilizan si desea saber si ese objeto todavía se utiliza en algún lugar. Por ejemplo, se utilizan para almacenar información sobre subprocesos y clases, de modo que cuando ya no se utiliza el subproceso o la clase, podemos descartar el metainfo relacionado con eso.

3) la referencia fantasma es como débil pero sin permitirle hacer referencia al objeto real. De esta manera, puede estar seguro de que pasar el fantasma no puede reanudar el objeto real (esto es un riesgo con una referencia débil). También la referencia fantasma está bloqueando el objeto que se va a recoger hasta que borres la referencia.

ReferenceQueue: no enque cosas allí. gc hará por ti. Le permiten saber cuándo se publican algunas referencias, sin tener que verificarlas una por una.

Answer 2

Si un objeto solo tiene WeakReference s (¡o ninguna referencia hacia él!), Puede ser recolectado como basura siempre que Java necesite hacer más espacio en la memoria. Por lo tanto, usa WeakReference s cada vez que desea que un objeto permanezca en la memoria, pero no lo necesita para permanecer TANTO (p. Ej., Si Java necesita recolectar basura, no hay problema, puede recuperarlo de alguna manera y en la media). Java tiene mejor rendimiento)

Poner en cola una WeakReference permite iterar el ReferenceQueue y determinar qué referencias se han recolectado como basura y cuáles no. Eso es todo, así que solo hazlo si necesitas saber esto.

Lea más: http://weblogs.java.net/blog/2006/05/04/understanding-weak-references

Answer 3

Un modismo común con colas de referencia es, por ejemplo, la subclase WeakReference para adjuntar la información que se necesita para limpiar las cosas, y luego sondear un ReferenceQueue para obtener tareas de limpieza.

ReferenceQueue<Foo> fooQueue = new ReferenceQueue<Foo>();

class ReferenceWithCleanup extends WeakReference<Foo> {
  Bar bar;
  ReferenceWithCleanup(Foo foo, Bar bar) {
    super(foo, fooQueue);
    this.bar = bar;
  }
  public void cleanUp() {
    bar.cleanUp();
  }
}

public Thread cleanupThread = new Thread() {
  public void run() {
    while(true) {
      ReferenceWithCleanup ref = (ReferenceWithCleanup)fooQueue.remove();
      ref.cleanUp();
    }
  }
}

public void doStuff() {
  cleanupThread.start();
  Foo foo = new Foo();
  Bar bar = new Bar();
  ReferenceWithCleanup ref = new ReferenceWithCleanup(foo, bar);
  ... // From now on, once you release all non-weak references to foo,
      // then at some indeterminate point in the future, bar.cleanUp() will
      // be run. You can force it by calling ref.enqueue().
}

Por ejemplo, los CacheBuilder internos de la implementación de CacheBuilder de Guava cuando se seleccionan las weakKeys uses este enfoque.

Answer 4

Una cosa común a hacer es crear mapas de referencias blandas.

Map<String, SoftReference<BigThing>> cache = new HashMap<>();
Set<String> thingsIAmCurrentlyGetting = new HashSet<String>();
Object mutex = new Object();

BigThing getThing(String key) {
  synchronized(mutex) {
    while(thingsIAmCurrentlyGetting.contains(key)) {
      mutex.wait();
    }
    SoftReference<BigThing> ref = cache.get(key);
    BigThing bigThing = ref == null ? null : ref.get();
    if(bigThing != null) return bigThing;
    thingsIAmCurrentlyGetting.add(key);
  }

  BigThing bigThing = getBigThing(key); // this may take a while to run.

  synchronized(mutex) {
    cache.put(key, bigThing);
    thingsIAmCurrentlyGetting.remove(key);
    mutex.notifyAll();
  }

  return bigThing;
}

Aquí le muestro mi antigua escuela: los nuevos paquetes de java probablemente tienen formas mucho mejores de hacerlo.