WeakReference

"Hello ulit!"

"Ngayon sasabihin ko sa iyo ang tungkol sa isa pang kamangha-manghang bagay: WeakReference ."

"Mukhang kapareho ito ng 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();

"Ang isang mahinang sanggunian ay may isa pang espesyal na tampok."

"Kung ang isang bagay ay walang mga ordinaryong sanggunian o malambot na sanggunian, ngunit mahina lamang na mga sanggunian, kung gayon ang bagay ay buhay, ngunit ito ay masisira sa susunod na koleksyon ng basura."

"Maaari mo bang sabihin iyon muli? Ano ang pagkakaiba ng mga sangguniang ito?"

"Ang isang bagay na pinanatili mula sa kamatayan sa pamamagitan lamang ng isang SoftReference ay maaaring mabuhay ng maraming koleksyon ng basura hangga't gusto mo at malamang na masisira kung walang sapat na memorya."

"Ang isang bagay na pinanatili mula sa kamatayan sa pamamagitan lamang ng isang WeakReference ay hindi makakaligtas sa susunod na koleksyon ng basura. Ngunit hanggang sa mangyari iyon, maaari mong makuha ang bagay sa pamamagitan ng pagtawag sa get() na pamamaraan sa WeakReference at pagkatapos ay tawagan ang mga pamamaraan nito o paggawa ng iba pa kasama nito ."

"Paano kung ang bagay ay tinutukoy ng parehong SoftReference at WeakReference?"

"Simple lang iyon. Kung kahit isang regular na reference ang tumuturo sa isang bagay, ito ay maituturing na buhay. Siyanga pala, ang nasabing reference ay tinatawag na StrongReference."

"Kung walang mga regular na sanggunian na tumuturo sa isang bagay, ngunit ang isang SoftReference ay tumuturo, kung gayon ito ay mahinang maabot."

"Kung walang mga regular na sanggunian o SoftReference na tumuturo sa isang bagay, ngunit ang isang WeakReference ay tumuturo, kung gayon ito ay mahinang maabot."

"Pag-isipan mo ito. Pinoprotektahan ng SoftReference ang object mula sa pagtanggal at sinisigurado na tatanggalin lang ang object kung walang sapat na memorya. Hinahawakan ng WeakReference ang object hanggang sa susunod na koleksyon ng basura. Nag-aalok ang SoftReference ng mas malaking pagtutol sa pagtanggal."

"Ah. Naiintindihan ko yata."

"Mahusay, pagkatapos ay sasabihin ko sa iyo ang tungkol sa isa pang kawili-wiling bagay na kinasasangkutan ng WeakReferences — ang WeakHashMap."

"Mukhang seryoso!"

"At pagkatapos ang ilan! Ang WeakHashMap ay isang HashMap na ang mga susi ay mahihinang mga sanggunian (WeakReferences)."

"Iyon ay, magdagdag ka ng mga bagay sa naturang HashMap at makipagtulungan sa kanila. Negosyo gaya ng dati."

"Hangga't ang mga bagay na iniimbak mo sa isang WeakHashMap ay may regular (malakas o malambot) na mga sanggunian bilang mga susi, ang mga bagay na ito ay magiging buhay."

"Ngunit ipagpalagay na wala nang mga sanggunian sa mga bagay na ito sa buong application. Ang lahat na pumipigil sa kanila na mamatay ay ilang mga WeakReferences sa loob ng WeakHashMap. Pagkatapos ng susunod na koleksyon ng basura, ang mga naturang bagay ay mawawala sa WeakHashMap. Mag-isa. Na parang sila ay hindi kailanman naroroon."

"I'm not sure naiintindihan ko."

"Nag-iimbak ka ng mga pares ng mga bagay sa isang WeakHashMap: isang susi at isang halaga. Ngunit hindi direktang tinutukoy ng WeakHashMap ang mga susi, ngunit sa halip ay sa pamamagitan ng WeakReferences. Samakatuwid, kapag ang mga bagay na ginamit bilang mga susi ay naging mahinang maabot, masisira sila sa susunod koleksyon ng basura. At bilang isang resulta, ang kanilang mga halaga ay awtomatikong inaalis sa WeakHashMap."

"Napakaginhawang gumamit ng WeakHashMap upang mag-imbak ng karagdagang impormasyon tungkol sa ilang partikular na bagay."

"Una sa lahat, ang pag-access sa impormasyon ay napakadali kung gagamitin mo ang bagay mismo bilang susi."

"Pangalawa, kung nawasak ang bagay, mawawala ito sa HashMap kasama ang lahat ng nauugnay na data."

"Halimbawa:

// 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. "Sa loob ng isang WeakHashMap, ang mga susi ay iniimbak bilang WeakReferences."
2. "Sa sandaling ang user object ay nawasak ng basurero, ang remove(user) method ay tahasang tinatawag sa loob ng WeakHashMap at anumang impormasyon na nauugnay sa user object ay awtomatikong aalisin mula sa WeakHashMap."

"Mukhang makapangyarihang kasangkapan ito. Saan ko ito magagamit?"

"Depende iyan sa mga pangyayari. Sabihin nating mayroon kang thread sa program na sumusubaybay sa gawain ng ilang mga gawain, na kinakatawan ng mga bagay, at nagsusulat ng impormasyon tungkol sa mga ito sa isang log. Maaaring iimbak ng thread na ito ang mga sinusubaybayang bagay sa isang WeakHashMap. Sa lalong madaling panahon dahil hindi kailangan ang mga bagay, tinatanggal sila ng tagakolekta ng basura, at ang mga sanggunian sa mga ito ay awtomatikong inaalis din sa WeakHashMap."

"Mukhang kawili-wili. Pakiramdam ko ay hindi pa ako nakakasulat ng anumang seryosong mga programa sa Java na sinasamantala ang gayong makapangyarihang mga mekanismo. Ngunit gagawin ko iyon. Maraming salamat, Ellie, para sa isang kawili-wiling aralin."