Référencefaible

"Rebonjour!"

"Maintenant, je vais vous parler d'une autre chose merveilleuse : WeakReference ."

"Cela ressemble presque à 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();

"Une référence faible a une autre particularité."

"Si un objet n'a pas de références ordinaires ou de références logicielles, mais uniquement des références faibles, alors l'objet est vivant, mais il sera détruit lors du prochain ramasse-miettes."

« Pouvez-vous répéter cela ? Quelle est la différence entre ces références ? »

"Un objet protégé de la mort uniquement par une SoftReference peut survivre à autant de ramasse-miettes que vous le souhaitez et sera probablement détruit s'il n'y a pas suffisamment de mémoire."

"Un objet gardé de la mort uniquement par une WeakReference ne survivra pas au prochain ramasse-miettes. Mais jusqu'à ce que cela se produise, vous pouvez obtenir l'objet en appelant la méthode get () sur la WeakReference , puis appeler ses méthodes ou faire autre chose avec elle ."

"Et si l'objet est référencé à la fois par une SoftReference et une WeakReference ?"

"C'est simple. Si au moins une référence régulière pointe vers un objet, il est considéré comme vivant. Au fait, une telle référence s'appelle une StrongReference."

"Si aucune référence régulière ne pointe vers un objet, mais qu'une SoftReference le fait, alors il est accessible en douceur."

"Si aucune référence régulière ou SoftReferences ne pointe vers un objet, mais qu'une WeakReference le fait, alors il est faiblement accessible."

"Pensez-y. Une SoftReference protège l'objet contre la suppression et garantit que l'objet ne sera supprimé que si la mémoire est insuffisante. Une WeakReference conserve l'objet jusqu'au prochain ramasse-miettes. Une SoftReference offre une plus grande résistance à la suppression."

"Ah. Je pense que je comprends."

"Génial, alors je vais vous parler d'une autre chose intéressante impliquant WeakReferences - le WeakHashMap."

"Ça a l'air sérieux !"

"Et puis certains! Un WeakHashMap est un HashMap dont les clés sont des références faibles (WeakReferences)."

"C'est-à-dire que vous ajoutez des objets à un tel HashMap et travaillez avec eux. Comme d'habitude."

"Tant que les objets que vous stockez dans un WeakHashMap ont des références régulières (fortes ou douces) comme clés, ces objets seront vivants."

"Mais supposons qu'il n'y ait plus de références à ces objets dans l'ensemble de l'application. Tout ce qui les empêche de mourir, ce sont quelques WeakReferences à l'intérieur du WeakHashMap. Après le prochain ramasse-miettes, ces objets disparaîtront du WeakHashMap. Par eux-mêmes. Comme s'ils n'ont jamais été là."

"Je ne suis pas sûre d'avoir compris."

"Vous stockez des paires d'objets dans un WeakHashMap : une clé et une valeur. Mais le WeakHashMap ne référence pas les clés directement, mais plutôt via WeakReferences. Par conséquent, lorsque les objets utilisés comme clés deviennent faiblement accessibles, ils sont détruits au prochain collecte des ordures. Et par conséquent, leurs valeurs sont également automatiquement supprimées de WeakHashMap."

"Il est très pratique d'utiliser un WeakHashMap pour stocker des informations supplémentaires sur certains objets."

"Tout d'abord, l'accès à l'information est très facile si vous utilisez l'objet lui-même comme clé."

"Deuxièmement, si l'objet est détruit, il disparaît du HashMap avec toutes les données associées."

"Par exemple:

// 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. "Dans un WeakHashMap, les clés sont stockées en tant que WeakReferences."
2. "Dès que l'objet utilisateur est détruit par le ramasse-miettes, la méthode remove(user) est implicitement appelée à l'intérieur de WeakHashMap et toute information associée à l'objet utilisateur est automatiquement supprimée de WeakHashMap."

« Cela ressemble à un outil puissant. Où puis-je l'utiliser ? »

"Cela dépend des circonstances. Disons que vous avez un fil dans le programme qui suit le travail de certaines tâches, représentées par des objets, et écrit des informations à leur sujet dans un journal. Ce fil pourrait stocker les objets surveillés dans un WeakHashMap. Dès comme les objets ne sont pas nécessaires, le ramasse-miettes les supprime et les références à ceux-ci sont également automatiquement supprimées du WeakHashMap."

"Ça a l'air intéressant. J'ai déjà l'impression de n'avoir encore écrit aucun programme Java sérieux qui tire parti de mécanismes aussi puissants. Mais je vais travailler dans ce sens. Merci beaucoup, Ellie, pour cette leçon si intéressante."