Course Modyul 3 - Lecture: Mga Junk Link sa Java

8.1 Mga mahihinang sanggunian sa Java

Mayroong ilang mga uri ng mga sanggunian sa Java.

Mayroong StrongReference - ito ang mga pinakakaraniwang link na ginagawa namin araw-araw.

Object object = new Object();//created an object
object = null;//can now be garbage collected

At mayroong tatlong "espesyal" na uri ng mga link - SoftReference, WeakReference, PhantomReference. Sa katunayan, may isang pagkakaiba lamang sa pagitan ng lahat ng uri ng mga link - ang pag-uugali ng GC sa mga bagay na kanilang tinutukoy. Tatalakayin natin ang mga detalye ng bawat uri ng link nang mas detalyado sa ibang pagkakataon, ngunit sa ngayon, sapat na ang sumusunod na kaalaman:

Ang SoftReference ay isang malambot na sanggunian, kung nakikita ng GC na ang isang bagay ay naa-access lamang sa pamamagitan ng isang hanay ng mga malambot na sanggunian, pagkatapos ay aalisin ito sa memorya. Siguro.
WeakReference - isang mahinang sanggunian, kung nakikita ng GC na ang isang bagay ay naa-access lamang sa pamamagitan ng isang hanay ng mga mahihinang sanggunian, pagkatapos ay aalisin ito sa memorya.
Ang PhantomReference ay isang phantom reference, kung nakita ng GC na ang isang bagay ay magagamit lamang sa pamamagitan ng isang hanay ng mga phantom reference, pagkatapos ay aalisin ito sa memorya. Pagkatapos ng ilang run ng GC.

Maaari mo ring sabihin na ang mga uri ng link ay may partikular na antas ng lambot:

Ang isang regular na hard link ay anumang variable ng isang uri ng sanggunian. Hindi nililinis ng basurero bago ito hindi magamit.
SoftReference . Ang bagay ay hindi magiging sanhi ng lahat ng memorya na maubos - ito ay garantisadong matatanggal bago mangyari ang isang OutOfMemoryError. Mas maaga siguro, depende sa implementasyon ng basurero.
WeakReference . Mas mahina malambot. Hindi pinipigilan ang bagay na itapon; hindi pinapansin ng tagakolekta ng basura ang mga naturang sanggunian.
PhantomReference . Ginagamit para sa pagproseso ng "kamatayan" ng isang bagay: ang bagay ay magagamit pagkatapos ng pagsasapinal hanggang sa ito ay makolekta ang basura.

Kung hindi pa malinaw kung ano ang pagkakaiba, pagkatapos ay huwag mag-alala, sa lalong madaling panahon ang lahat ay mahuhulog sa lugar. Ang mga detalye ay nasa mga detalye, at ang mga detalye ay susunod.

8.2 WeakReference at SoftReference sa Java

Una, tingnan natin ang pagkakaiba sa pagitan ng WeakReference at SoftReference sa Java.

Sa madaling sabi, ang tagakolekta ng basura ay magpapalaya sa memorya ng isang bagay kung ang mga mahihinang sanggunian lamang ang tumuturo dito. Kung ang bagay ay itinuro sa pamamagitan ng SoftReferences, pagkatapos ay ang memorya ay deallocated kapag ang JVM ay lubhang nangangailangan ng memorya.

Nagbibigay ito ng tiyak na kalamangan sa SoftReference kaysa sa Strong reference sa ilang partikular na kaso. Halimbawa, ginagamit ang SoftReference upang magpatupad ng cache ng application, kaya ang unang gagawin ng JVM ay magtanggal ng mga bagay na tinuturo lamang ng SoftReference.

Ang WeakReference ay mahusay para sa pag-iimbak ng metadata, tulad ng pag-iimbak ng reference sa isang ClassLoader. Kung walang klase na na-load, hindi ka dapat sumangguni sa ClassLoader. Ito ang dahilan kung bakit ginagawang posible ng WeakReference para sa kolektor ng basura na gawin ang trabaho nito sa ClassLoader sa sandaling maalis ang huling malakas na reference dito.

Halimbawa ng WeakReference sa Java:

// some object
Student student = new Student();

// weak reference to it
WeakReference weakStudent = new WeakReference(student);

// now the Student object can be garbage collected
student = null;

Halimbawa ng SoftReference sa Java:

// some object
Student student = new Student();

// weak reference to it
SoftReference softStudent = new SoftReference(student)

// now the Student object can be garbage collected
// but this will only happen if the JVM has a strong need for memory
student = null;

8.3 PhantomReference sa Java

Ang halimbawa ng PhantomReference ay nilikha sa parehong paraan tulad ng sa mga halimbawa ng WeakReference at SoftReference, ngunit ito ay bihirang ginagamit.

Ang isang PhantomReference ay maaaring makolektang basura kung ang bagay ay walang malakas (Malakas), mahina (WeakReference), o malambot (SoftReference) na mga sanggunian.

Maaari kang lumikha ng isang bagay na Phantom Reference tulad nito:

PhantomReference myObjectRef = new PhantomReference(MyObject);

Maaaring gamitin ang PhantomReference sa mga sitwasyon kung saan walang saysay ang finalize(). Ang uri ng sanggunian na ito ay naiiba sa iba pang mga uri dahil hindi ito idinisenyo upang ma-access ang isang bagay. Ito ay isang senyales na ang bagay ay natapos na at ang basurero ay handa nang bawiin ang memorya nito.

Upang gawin ito, inilalagay ito ng tagakolekta ng basura sa isang espesyal na ReferenceQueue para sa karagdagang pagproseso. Ang ReferenceQueue ay kung saan inilalagay ang mga object reference sa libreng memorya.

Ang mga sanggunian ng phantom ay isang ligtas na paraan upang malaman na ang isang bagay ay inalis sa memorya. Halimbawa, isaalang-alang ang isang application na tumatalakay sa malalaking larawan. Sabihin nating gusto nating mag-load ng isang imahe sa memorya kapag nasa memorya na ito, na handa na para sa koleksyon ng basura. Sa kasong ito, gusto naming hintayin na patayin ng tagakolekta ng basura ang lumang imahe bago i-load ang bagong imahe sa memorya.

Narito ang PhantomReference ay isang nababaluktot at ligtas na pagpipilian. Ang reference sa lumang imahe ay ipapasa sa ReferenceQueue pagkatapos masira ang lumang bagay ng imahe. Kapag mayroon na tayong link na ito, mai-load natin ang bagong imahe sa memorya.