Mga pagkakaiba sa pagitan ng mahina, malambot, phantom at regular na mga sanggunian sa Java

Ang mga "mahina" na sanggunian at "malambot" na mga sanggunian (WeakReference, SoftReference) ay naidagdag sa Java API matagal na ang nakalipas, ngunit hindi lahat ng programmer ay pamilyar sa kanila. Ito ay nagpapahiwatig ng isang agwat sa pag-unawa kung saan at kung paano gamitin ang mga ito. Ang mga klase ng sanggunian ay lalong mahalaga sa konteksto ng pangongolekta ng basura . Tulad ng alam nating lahat, ang garbage collector mismo ay nagpapalaya sa memorya na inookupahan ng mga bagay, ngunit hindi lahat ng programmer ay alam na gumagawa ito ng desisyon na magbakante ng memorya batay sa uri ng mga sanggunian na magagamit sa bagay. Ang pangunahing pagkakaiba sa pagitan ng SoftReference at WeakReference ay kung paano gagana ang kolektor sa kanila. Maaari itong magtanggal ng isang bagay anumang oras kung ang mga mahihinang link lamang ang tumuturo dito, sa kabilang banda, ang mga bagay na may malambot na link ay kokolektahin lamang kapag ang JVM ay talagang nangangailangan ng memorya. Dahil sa mga tampok na ito ng mga klase ng sanggunian, ang bawat isa sa kanila ay may sariling gamit. Ang SoftReference ay maaaring gamitin upang ipatupad ang mga cache at kapag ang JVM ay nangangailangan ng memorya ito ay magpapalaya nito sa pamamagitan ng pagtanggal ng mga naturang bagay. At ang WeakReferences ay mahusay para sa pag-iimbak ng metadata, halimbawa, pag-iimbak ng isang link sa isang ClassLoader. Kung walang mga klase na ilo-load, walang saysay na mag-imbak ng reference sa ClassLoader , ginagawang available ng mahinang reference ang ClassLoader para maalis sa sandaling italaga namin ito sa halip na isang Strong reference. Sa artikulong ito titingnan natin ang mga pagkakaiba sa pagitan ng mga uri ng link, kabilang ang Strong reference at Phantom reference .

WeakReference kumpara sa SoftReference sa Java

Para sa mga hindi nakakaalam, mayroong 4 na uri ng mga link:

1. Malakas na sanggunian
2. Mahinang Sanggunian
3. Malambot na sanggunian
4. Phantom Reference

Ang malakas na link ay ang pinakasimpleng, dahil ginagamit namin ito sa programming araw-araw, halimbawa, sa code tulad ng String s = "abc" ang variable s ay ang malakas na link. Ang anumang bagay na may malakas na sanggunian ay ipinagbabawal na alisin ng basurero. Siyempre, ito ay mga bagay na kailangan ng Java program. Ang mga mahihinang sanggunian ay kinakatawan ng java.lang.ref.WeakReference class , maaari mong tukuyin ang mahinang sanggunian tulad nito:

Counter counter = new Counter(); // strong reference
WeakReference weakCounter = new WeakReference(counter); //weak reference
counter = null; // now Counter object is eligible for garbage collection

Ngayon, sa sandaling itakda mo ang malakas na reference counter sa null (counter = null), ang object na ginawa sa unang linya ay magiging available para sa koleksyon ng basura dahil wala na itong malakas na reference. Ang weakCounter reference na ginawa ng Weak ay hindi mapipigilan ang collector na tanggalin ang Counter object. Sa kabilang banda, kung ito ay isang Soft reference, ang Counter object ay hindi matatanggal hanggang ang JVM ay may partikular na mataas na pangangailangan para sa memorya. Ang mga soft reference sa Java ay kinakatawan ng java.lang.ref.SoftReference class . Halimbawa ng paglikha ng SoftReference sa Java

Counter prime = new Counter();  // prime holds a strong reference
SoftReference soft = new SoftReference(prime) ; //soft reference variable has SoftReference to Counter Object
prime = null;  // now Counter object is eligible for garbage collection but only be collected when JVM absolutely needs memory

Pagkatapos i-clear ang malakas na reference (sa ika-3 linya), 1 soft reference na lang ang mananatili sa Counter object, na hindi mapipigilan ang garbage collector na tanggalin ang object na ito, ngunit hindi tulad ng mahinang reference, magagawa nitong ipagpaliban prosesong ito hanggang sa magkaroon ng matinding kakulangan sa memorya. Dahil sa pagkakaibang ito sa pagitan ng mga malambot na link at mahihinang link, ang una ay mas angkop para sa mga cache, at mahina para sa metadata. Ang isang magandang halimbawa ay ang klase ng WeakHashMap, na isang inapo ng interface ng Map tulad ng mga klase ng HashMap o TreeMap , ngunit may isang natatanging tampok. Binabalot ng WeakHashMap ang mga susi bilang mga mahihinang sanggunian, na nangangahulugan na sa sandaling walang malakas na sanggunian sa isang bagay, ang mahihinang sanggunian na matatagpuan sa loob ng WeakHashMap ay hindi magliligtas sa iyo mula sa kolektor ng basura. Ang mga phantom link ay ang ikatlong uri ng mga link na available sa java.lang.ref package. Ang mga Phantom reference ay kinakatawan ng java.lang.ref.PhantomReference class . Ang isang bagay na itinuro lamang ng mga link ng phantom ay maaaring tanggalin ng kolektor anumang oras. Ang isang Phantom link ay nilikha sa parehong paraan tulad ng isang mahina o malambot na link.

DigitalCounter digit = new DigitalCounter(); // digit reference variable has strong reference
PhantomReference phantom = new PhantomReference(digit); // phantom reference
digit = null;

Kapag na-clear mo na ang mga malakas na reference sa DigitalCounter object, tatanggalin ito ng garbage collector anumang oras, dahil ngayon ay phantom reference na lang ang tumuturo dito. Bilang karagdagan sa mga klase ng WeakReference, SoftReference, PhantomReference, WeakHashMap, kapaki-pakinabang na malaman ang tungkol sa ReferenceQueue class . Magagamit mo ang klase na ito kapag gumagawa ng WeakReference, SoftReference, o PhantomReference object:

ReferenceQueue refQueue = new ReferenceQueue(); //reference will be stored in this queue for cleanup
DigitalCounter digit = new DigitalCounter();
PhantomReference phantom = new PhantomReference(digit, refQueue);

Ang object reference ay idaragdag sa ReferenceQueue at masusubaybayan mo ang estado ng mga reference sa pamamagitan ng pagboto sa ReferenceQueue. Ang ikot ng buhay ng Object ay mahusay na kinakatawan sa diagram na ito: Iyan lang ang mga pagkakaiba sa pagitan ng mahina at malambot na mga sanggunian sa Java . Nakilala rin namin ang mga phantom link, ang WeakHashMap class at ReferenceQueue . Ang wastong paggamit ng mga sanggunian ay makakatulong sa pagkolekta ng basura at magreresulta sa mas nababaluktot na pamamahala ng memorya sa Java . Orihinal na artikulo