Riferimento debole

"Ciao di nuovo!"

"Ora ti parlerò di un'altra cosa meravigliosa: WeakReference ."

"Sembra quasi uguale a 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();

"Un riferimento debole ha un'altra caratteristica speciale."

"Se un oggetto non ha riferimenti ordinari o riferimenti soft, ma solo riferimenti deboli, allora l'oggetto è vivo, ma verrà distrutto alla prossima raccolta dei rifiuti."

"Puoi dirlo di nuovo? Qual è la differenza tra questi riferimenti?"

"Un oggetto preservato dalla morte solo da un SoftReference può sopravvivere a tutte le raccolte di rifiuti che desideri e probabilmente verrà distrutto se la memoria è insufficiente."

"Un oggetto preservato dalla morte solo da un WeakReference non sopravviverà alla prossima raccolta di rifiuti. Ma fino a quando ciò non accadrà, puoi ottenere l'oggetto chiamando il metodo get() su WeakReference e quindi chiamare i suoi metodi o fare qualcos'altro con esso ."

"Cosa succede se l'oggetto fa riferimento sia a SoftReference che a WeakReference?"

"È semplice. Se almeno un riferimento regolare punta a un oggetto, è considerato vivo. A proposito, un tale riferimento è chiamato StrongReference."

"Se nessun riferimento regolare punta a un oggetto, ma un SoftReference lo fa, allora è facilmente raggiungibile."

"Se nessun riferimento regolare o SoftReference punta a un oggetto, ma un WeakReference lo fa, allora è debolmente raggiungibile."

"Pensaci. Un SoftReference protegge l'oggetto dall'eliminazione e garantisce che l'oggetto venga eliminato solo se la memoria è insufficiente. Un WeakReference trattiene l'oggetto fino alla successiva raccolta dei rifiuti. Un SoftReference offre una maggiore resistenza all'eliminazione."

"Ah. Penso di aver capito."

"Fantastico, allora ti parlerò di un'altra cosa interessante che coinvolge WeakReferences: WeakHashMap."

"Sembra serio!"

"E poi alcuni! Una WeakHashMap è una HashMap le cui chiavi sono riferimenti deboli (WeakReferences)."

"Cioè, aggiungi oggetti a una tale HashMap e lavori con loro. Affari come al solito."

"Finché gli oggetti che memorizzi in una WeakHashMap hanno riferimenti regolari (forti o morbidi) come chiavi, questi oggetti saranno vivi."

"Ma supponiamo che non ci siano più riferimenti a questi oggetti nell'intera applicazione. Tutto ciò che impedisce loro di morire sono alcuni WeakReferences all'interno della WeakHashMap. Dopo la successiva raccolta dei rifiuti, tali oggetti scompariranno dalla WeakHashMap. Da soli. Come se non c'erano mai".

"Non sono sicuro di aver capito."

"Memorizzi coppie di oggetti in una WeakHashMap: una chiave e un valore. Ma la WeakHashMap non fa riferimento direttamente alle chiavi, ma piuttosto tramite WeakReferences. Pertanto, quando gli oggetti usati come chiavi diventano debolmente raggiungibili, vengono distrutti alla successiva Garbage Collection. Di conseguenza, anche i loro valori vengono rimossi automaticamente da WeakHashMap."

"È molto conveniente utilizzare WeakHashMap per memorizzare informazioni aggiuntive su determinati oggetti."

"Prima di tutto, l'accesso alle informazioni è molto semplice se si utilizza l'oggetto stesso come chiave."

"In secondo luogo, se l'oggetto viene distrutto, scompare dalla HashMap insieme a tutti i dati associati."

"Per esempio:

// 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);

1. "All'interno di una WeakHashMap, le chiavi sono memorizzate come WeakReferences."
2. "Non appena l'oggetto utente viene distrutto dal Garbage Collector, il metodo remove(user) viene chiamato implicitamente all'interno di WeakHashMap e qualsiasi informazione associata all'oggetto utente viene rimossa automaticamente da WeakHashMap."

"Sembra uno strumento potente. Dove posso usarlo?"

"Dipende dalle circostanze. Supponiamo che tu abbia un thread nel programma che tiene traccia del lavoro di alcune attività, rappresentate da oggetti, e scrive informazioni su di essi in un registro. Questo thread potrebbe archiviare gli oggetti monitorati in una WeakHashMap. Non appena poiché gli oggetti non sono necessari, il Garbage Collector li elimina e anche i riferimenti ad essi vengono automaticamente rimossi da WeakHashMap."

"Sembra interessante. Mi sento già come se non avessi ancora scritto nessun programma Java serio che sfrutti meccanismi così potenti. Ma lavorerò per questo. Grazie mille, Ellie, per questa lezione così interessante."