Differenze tra riferimenti deboli, morbidi, fantasma e regolari in Java

I riferimenti "deboli" e i riferimenti "soft" (WeakReference, SoftReference) sono stati aggiunti all'API Java molto tempo fa, ma non tutti i programmatori li conoscono. Ciò indica una lacuna nella comprensione di dove e come utilizzarli. Le classi di riferimento sono particolarmente importanti nel contesto della garbage collection . Come tutti sappiamo, è proprio il garbage collector a liberare la memoria occupata dagli oggetti, ma non tutti i programmatori sanno che decide di liberare memoria in base al tipo di riferimenti a disposizione dell'oggetto. La differenza principale tra SoftReference e WeakReference è il modo in cui il raccoglitore lavorerà con loro. Può eliminare un oggetto in qualsiasi momento se solo i collegamenti deboli lo puntano, d'altra parte, gli oggetti con un collegamento soft verranno raccolti solo quando la JVM ha realmente bisogno di memoria. A causa di queste caratteristiche delle classi di riferimento, ognuna di esse ha il proprio utilizzo. SoftReference può essere utilizzato per implementare le cache e quando la JVM necessita di memoria la libererà eliminando tali oggetti. E WeakReferences è ottimo per archiviare metadati, ad esempio, archiviare un collegamento a un ClassLoader. Se non ci sono classi da caricare allora non ha senso memorizzare un riferimento al ClassLoader , un riferimento debole rende il ClassLoader disponibile per la rimozione non appena lo assegniamo al posto di un riferimento Strong. In questo articolo esamineremo le differenze tra i tipi di collegamento, inclusi Riferimento forte e Riferimento fantasma .

WeakReference vs SoftReference in Java

Per chi non lo sapesse, ci sono 4 tipi di link:

1. Riferimento forte
2. Riferimento debole
3. Riferimento morbido
4. Riferimento fantasma

Il collegamento forte è il più semplice, poiché lo usiamo ogni giorno nella programmazione, ad esempio, in codice come String s = “abc” la variabile s è il collegamento forte. Qualsiasi oggetto che abbia un riferimento forte non può essere rimosso dal Garbage Collector. Naturalmente, questi sono oggetti di cui ha bisogno il programma Java . I riferimenti deboli sono rappresentati dalla classe java.lang.ref.WeakReference , puoi definire un riferimento debole in questo modo:

Counter counter = new Counter(); // strong reference
WeakReference weakCounter = new WeakReference(counter); //weak reference
counter = null; // now Counter object is eligible for garbage collection

Ora, una volta impostato il contatore dei riferimenti forti su null (contatore = null), l'oggetto creato nella prima riga diventa disponibile per la raccolta della Garbage Collection perché non ha più un riferimento forte. Il riferimento deboleCounter creato da Weak non può impedire al raccoglitore di eliminare l'oggetto Counter. D'altra parte, se fosse un riferimento Soft, l'oggetto Counter non verrebbe eliminato finché la JVM non avesse un fabbisogno di memoria particolarmente elevato. I riferimenti software in Java sono rappresentati dalla classe java.lang.ref.SoftReference . Esempio di creazione di un SoftReference in Java

Counter prime = new Counter();  // prime holds a strong reference
SoftReference soft = new SoftReference(prime) ; //soft reference variable has SoftReference to Counter Object
prime = null;  // now Counter object is eligible for garbage collection but only be collected when JVM absolutely needs memory

Dopo aver cancellato il riferimento forte (nella 3a riga), rimarrà solo 1 riferimento morbido all'oggetto Counter, che non sarà in grado di impedire al Garbage Collector di eliminare questo oggetto, ma a differenza di un riferimento debole, sarà in grado di posticipare questo processo fino a quando non si verifica una grave carenza di memoria. Data questa differenza tra collegamenti soft e collegamenti deboli, il primo è più adatto per le cache e debole per i metadati. Un buon esempio è la classe WeakHashMap, che è una discendente dell'interfaccia Map come le classi HashMap o TreeMap , ma con una caratteristica distintiva. WeakHashMap avvolge le chiavi come riferimenti deboli, il che significa che non appena non ci sono riferimenti forti a un oggetto, i riferimenti deboli che si trovano all'interno di WeakHashMap non ti salveranno dal garbage collector. I collegamenti fantasma sono il terzo tipo di collegamenti disponibili nel pacchetto java.lang.ref. I riferimenti fantasma sono rappresentati dalla classe java.lang.ref.PhantomReference . Un oggetto puntato solo da collegamenti fantasma può essere eliminato dal raccoglitore in qualsiasi momento. Un collegamento fantasma viene creato allo stesso modo di un collegamento debole o morbido.

DigitalCounter digit = new DigitalCounter(); // digit reference variable has strong reference
PhantomReference phantom = new PhantomReference(digit); // phantom reference
digit = null;

Una volta cancellati i riferimenti forti all'oggetto DigitalCounter, il garbage collector lo eliminerà in qualsiasi momento, poiché ora puntano ad esso solo i riferimenti fantasma. Oltre alle classi WeakReference, SoftReference, PhantomReference, WeakHashMap, è utile conoscere la classe ReferenceQueue . Puoi utilizzare questa classe durante la creazione di un oggetto WeakReference, SoftReference o PhantomReference:

ReferenceQueue refQueue = new ReferenceQueue(); //reference will be stored in this queue for cleanup
DigitalCounter digit = new DigitalCounter();
PhantomReference phantom = new PhantomReference(digit, refQueue);

Il riferimento all'oggetto verrà aggiunto a ReferenceQueue ed è possibile monitorare lo stato dei riferimenti eseguendo il polling di ReferenceQueue. Il ciclo di vita di Object è ben rappresentato in questo diagramma: ecco tutte le differenze tra riferimenti deboli e soft in Java . Abbiamo anche conosciuto i collegamenti fantasma, la classe WeakHashMap e ReferenceQueue . L'utilizzo corretto dei riferimenti aiuterà con la garbage collection e comporterà una gestione della memoria più flessibile in Java . Articolo originale