Zwakke referentie

"Welkom terug!"

"Nu ga ik je nog iets geweldigs vertellen: WeakReference ."

"Het ziet er bijna hetzelfde uit als 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();

"Een zwakke referentie heeft nog een bijzonderheid."

"Als een object geen gewone referenties of zachte referenties heeft, maar alleen zwakke referenties, dan leeft het object, maar wordt het vernietigd bij de volgende opruimactie."

'Kun je dat nog een keer zeggen? Wat is het verschil tussen deze verwijzingen?'

"Een object dat alleen door een SoftReference van de dood wordt gehouden , kan zoveel afvalverzamelingen overleven als je wilt en zal waarschijnlijk worden vernietigd als er onvoldoende geheugen is."

"Een object dat alleen door een WeakReference voor dood wordt gehouden , overleeft de volgende garbage collection niet. Maar totdat dat gebeurt, kun je het object verkrijgen door de methode get() op de WeakReference aan te roepen en vervolgens zijn methoden aan te roepen of er iets anders mee te doen ."

"Wat als er naar het object wordt verwezen door zowel een SoftReference als een WeakReference?"

"Dat is simpel. Als er minstens één reguliere verwijzing naar een object verwijst, wordt het als levend beschouwd. Zo'n verwijzing wordt trouwens een StrongReference genoemd."

"Als geen reguliere referenties naar een object verwijzen, maar een SoftReference wel, dan is het zacht bereikbaar."

"Als geen reguliere referenties of SoftReferences naar een object verwijzen, maar een WeakReference wel, dan is het zwak bereikbaar."

"Denk er eens over na. Een SoftReference beschermt het object tegen verwijdering en zorgt ervoor dat het object alleen wordt verwijderd als er onvoldoende geheugen is. Een WeakReference bewaart het object tot de volgende opschoonactie. Een SoftReference biedt meer weerstand tegen verwijdering."

"Ah. Ik denk dat ik het begrijp."

"Geweldig, dan zal ik je vertellen over nog iets interessants met betrekking tot WeakReferences - de WeakHashMap."

"Klinkt serieus!"

"En nog wat! Een WeakHashMap is een HashMap waarvan de sleutels zwakke referenties zijn (WeakReferences)."

"Dat wil zeggen, je voegt objecten toe aan zo'n HashMap en gaat ermee aan de slag. Business as usual."

"Zolang de objecten die u opslaat in een WeakHashMap regelmatige (sterke of zachte) referenties als sleutels hebben, zullen deze objecten leven."

"Maar stel dat er geen verwijzingen meer zijn naar deze objecten in de hele applicatie. Het enige dat ervoor zorgt dat ze niet doodgaan, zijn een paar WeakReferences in de WeakHashMap. Na de volgende afvalverzameling zullen dergelijke objecten uit de WeakHashMap verdwijnen. Alsof ze waren er nooit."

"Ik weet niet zeker of ik het begrepen heb."

"Je slaat paren objecten op in een WeakHashMap: een sleutel en een waarde. Maar de WeakHashMap verwijst niet rechtstreeks naar de sleutels, maar via WeakReferences. Daarom, wanneer de objecten die als sleutels worden gebruikt zwak bereikbaar worden, worden ze vernietigd bij de volgende garbage collection. En als resultaat worden hun waarden ook automatisch verwijderd uit de WeakHashMap."

"Het is erg handig om een ​​WeakHashMap te gebruiken om aanvullende informatie over bepaalde objecten op te slaan."

"Allereerst is toegang tot de informatie heel eenvoudig als je het object zelf als sleutel gebruikt."

"Ten tweede, als het object wordt vernietigd, verdwijnt het uit de HashMap samen met alle bijbehorende gegevens."

"Bijvoorbeeld:

// 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. "In een WeakHashMap worden sleutels opgeslagen als WeakReferences."
2. "Zodra het gebruikersobject wordt vernietigd door de vuilnisman, wordt de methode remove(user) impliciet aangeroepen in de WeakHashMap en alle informatie die aan het gebruikersobject is gekoppeld, wordt automatisch verwijderd uit de WeakHashMap."

"Dit ziet eruit als een krachtig hulpmiddel. Waar kan ik het gebruiken?"

"Dat hangt af van de omstandigheden. Laten we zeggen dat je een thread in het programma hebt die het werk van sommige taken, vertegenwoordigd door objecten, bijhoudt en informatie daarover naar een logboek schrijft. Deze thread kan de gecontroleerde objecten opslaan in een WeakHashMap. Zodra aangezien de objecten niet nodig zijn, verwijdert de vuilnisman ze en worden de verwijzingen daarnaar ook automatisch verwijderd uit de WeakHashMap."

'Klinkt interessant. Ik heb nu al het gevoel dat ik nog geen serieuze Java-programma's heb geschreven die gebruik maken van zulke krachtige mechanismen. Maar daar zal ik aan werken. Heel erg bedankt, Ellie, voor zo'n interessante les.'