Pagkolekta ng basura

"Hi! I decided to give you another small lesson about garbage collection."

Tulad ng alam mo na, ang Java machine mismo ay sumusubaybay kapag ang isang bagay ay nagiging hindi kailangan, at tinatanggal ito.

"Yep. You and Rishi told me about it kanina. I don't remember the details."

"OK. Tapos ulitin natin."

"Sa sandaling malikha ang isang bagay, ang JVM ay naglalaan ng memorya para dito. Ang interes sa bagay ay sinusubaybayan gamit ang mga sangguniang variable. Ang  isang bagay ay maaaring tanggalin sa panahon ng pagkolekta ng basura, ibig sabihin, ang pamamaraan kung saan ang memorya ay inilabas kung walang mga variable na tumutukoy sa bagay. "

"Sabihin sa akin ng kaunti tungkol sa kolektor ng basura—ano ito at kung paano ito gumagana."

"OK. Dati nangyayari ang pangongolekta ng basura sa pangunahing thread. Bawat 5 minuto, o mas madalas. Kung walang sapat na libreng memorya, sususpindihin ng Java machine ang lahat ng mga thread at tatanggalin ang mga hindi nagamit na bagay. "

"Ngunit ang diskarte na ito ay inabandona na ngayon. Ang susunod na gen na kolektor ng basura ay gumagana sa likod ng mga eksena at sa isang hiwalay na thread. Ito ay tinatawag na concurrent garbage collection."

"I see. How exactly is the decision to delete an object or not made?"

"Ang pagbibilang lamang ng bilang ng mga sanggunian sa isang bagay ay hindi masyadong epektibo—maaaring may mga bagay na tumutukoy sa isa't isa, ngunit walang ibang mga bagay na tinutukoy."

"Kaya ang Java ay gumagamit ng ibang diskarte.  Hinahati ng Java ang mga bagay sa maabot at hindi maabot.  Ang isang bagay ay naaabot (buhay) kung ito ay tinutukoy ng isa pang naaabot (nabubuhay) na bagay. Ang kakayahang maabot ay tinutukoy mula sa mga thread. Ang mga tumatakbong thread ay palaging itinuturing na naaabot (buhay) , kahit na walang sumangguni sa kanila."

"OK. I think I get it."

"Paano nangyayari ang aktwal na pangongolekta ng basura—ang pagtanggal ng mga hindi kinakailangang bagay?"

"Simple lang. Sa Java, ang memorya ay nahahati sa dalawang bahagi ayon sa convention, at kapag oras na para sa koleksyon ng basura, lahat ng nabubuhay (naaabot) na mga bagay ay kinokopya sa isa pang bahagi ng memorya, at ang lumang memorya ay inilabas lahat."

"Iyan ay isang kawili-wiling diskarte. Hindi na kailangang magbilang ng mga sanggunian: kopyahin ang lahat ng naaabot na mga bagay, at lahat ng iba pa ay basura."

"Ito ay medyo mas kumplikado kaysa doon. Nalaman ng mga programmer ng Java na ang mga bagay ay karaniwang nahahati sa dalawang kategorya: pangmatagalan (na umiiral sa buong oras na tumatakbo ang programa) at panandalian (na kailangan sa mga pamamaraan at para sa pagganap ng «lokal » mga operasyon)."

"Mas mahusay na panatilihing hiwalay ang mga pangmatagalang bagay sa mga maikli ang buhay. Upang magawa ito, kinailangan na gumawa ng paraan upang matukoy ang mahabang buhay ng bagay."

"Kaya, hinati nila ang lahat ng memorya sa «mga henerasyon». May mga first-generation object, second-generation object, atbp. Sa bawat oras na na-clear ang memorya, ang generation counter ay dinadagdagan ng 1. Kung ang ilang mga object ay umiiral sa maraming henerasyon, kung gayon sila ay naitala bilang mahabang buhay."

"Ngayon, ang garbage collector ay isang napakakomplikado at mahusay na bahagi ng Java. Marami sa mga bahagi nito ay gumagana nang heuristiko—batay sa mga algorithm na gumagawa ng mga hula. Bilang resulta, madalas itong «hindi nakikinig» sa gumagamit."

"Ibig sabihin?"

"Ang Java ay mayroong garbage collector ( GC ) object na maaaring tawagan gamit ang System.gc () method."

"Maaari mo ring gamitin ang System.runFinalization() upang pilitin ang mga tawag sa pag-finalize ng mga pamamaraan ng mga bagay na tatanggalin. Ngunit ang katotohanan ay, ayon sa dokumentasyon ng Java, ang garantiyang ito ay hindi magsisimula ang pagkolekta ng basura, o ang pagsasapinal( ) paraan ang tatawagin.  Ang basurero ang magpapasya kung kailan ito tatawag at kung ano. "

"Whoa! Magandang malaman."

"Ngunit mayroong higit pa. Tulad ng alam mo, sa Java, ang ilang mga bagay ay tumutukoy sa iba. Ang network ng mga sanggunian na ito ay ginagamit upang matukoy kung ang isang bagay ay dapat tanggalin."

"At, tingnan mo. May mga espesyal na sanggunian ang Java na nagbibigay-daan sa iyong maimpluwensyahan ang prosesong ito. May mga espesyal na klase ng wrapper para sa kanila. Narito ang mga ito:"

" Ang SoftReference  ay isang malambot na sanggunian."

" Ang WeakReference  ay isang mahinang reference."

" Ang PhantomReference ay isang phantom reference."

"Uh... Ito ay nagpapaalala sa akin ng mga inner class, nested class, nested anonymous na klase, at lokal na klase. Magkaiba ang mga pangalan, ngunit hindi malinaw kung para saan ang mga ito."

"Sabihin mo, Amigo, naging programmer ka. Ngayon galit ka dahil sa mga pangalan ng klase, sinasabing «hindi sila sapat na impormasyon, at imposible sa isang pangalan(!) upang matukoy kung ano ang ginagawa ng klase, kung paano, at bakit"."

"Wow. Hindi ko man lang napansin. Pero sobrang obvious."

"OK. Enough words. Let me tell you about SoftReferences."

"Ang mga sanggunian na ito ay partikular na idinisenyo para sa pag-cache, bagaman maaari silang magamit para sa iba pang mga layunin-lahat sa pagpapasya ng programmer."

"Narito ang isang halimbawa ng naturang sanggunian:"

// Create a Cat object
Cat cat = new Cat();

// Create a soft reference to a Cat object
SoftReference<Cat> catRef = new SoftReference<Cat>(cat);

// Now only the catRef soft reference points at the object
cat = null;

// Now the ordinary cat variable also references the object
cat = catRef.get();

// Clear the soft reference
catRef.clear();

"Kung ang tanging mga sanggunian sa isang bagay ay malambot, pagkatapos ay patuloy itong mabubuhay at tinatawag na 'malambot na maabot'."

"Ngunit!  Ang isang bagay na isinangguni lamang ng mga malambot na sanggunian ay maaaring tanggalin ng tagakolekta ng basura kung ang programa ay walang sapat na memorya.  Kung biglang ang programa ay walang sapat na memorya, bago magtapon ng OutOfMemoryException , tatanggalin ng kolektor ng basura ang lahat ng mga bagay. isinangguni ng malambot na mga sanggunian at susubukang muli na maglaan ng memorya sa programa."

"Ipagpalagay na ang isang client program ay madalas na humihiling ng iba't ibang data mula sa isang server program. Ang server program ay maaaring gumamit ng isang SoftReference upang i-cache ang ilan sa mga ito. Kung ang mga bagay na iniingatan mula sa kamatayan sa pamamagitan ng malambot na mga sanggunian ay tumatagal ng isang malaking bahagi ng memorya, pagkatapos ay tatanggalin lamang sila ng kolektor ng basura. lahat. Ang ganda!"

"Oo. Nagustuhan ko mismo."

"Well, isang maliit na karagdagan: Ang klase ng SoftReference ay may dalawang pamamaraan. Ibinabalik ng get() method ang object na isinangguni ng SoftReference . Kung ang object ay tinanggal ng garbage collector, ang get () method ay biglang magsisimulang bumalik na null."

"Maaari ding i-clear ng user ang SoftReference nang tahasan sa pamamagitan ng pagtawag sa clear() na paraan. Sa kasong ito, masisira ang mahinang link sa loob ng SoftReference object."

"Yun lang muna."

"Salamat sa kawili-wiling kuwento, Ellie. Talagang napaka-interesante."