Higit pa tungkol sa kolektor ng basura sa Java

Kamusta! Sa huling lecture, una naming nakilala ang built-in na mekanismo ng Java language - ang garbage collector. Gumagana ito sa background habang tumatakbo ang iyong program, nangongolekta ng mga bagay na hindi na kailangan, na tatanggalin sa ibang pagkakataon. Sa ganitong paraan, pinapalaya nito ang memorya para sa paglikha ng mga bagong bagay sa hinaharap. Sa panayam na ito ay titingnan natin ang prinsipyo ng pagpapatakbo nito. Halimbawa, paano at sa anong punto nagiging hindi kailangan ang isang bagay? At paano nalaman ng basurero ang tungkol dito? Sasagutin namin ang mga tanong na ito :) Ang aming panayam ay higit na isang pangkalahatang-ideya: ang materyal na ito ay hindi kailangang isaulo. Ito ay inilaan upang palawakin ang iyong mga abot-tanaw tungkol sa gawain ng memorya at ang kolektor ng basura, kaya ito ay sapat na upang basahin ito at matuto ng bago para sa iyong sarili :) Tara na! Ang unang bagay na kailangan mong tandaan ay ang tagakolekta ng basura ay tumatakbo nang kahanay sa iyong programa . Ito ay hindi bahagi nito at gumagana nang hiwalay: upang ilarawan ito, sa huling panayam nagbigay kami ng isang pagkakatulad sa isang robot vacuum cleaner. Sa katunayan, hindi ito palaging nangyari. Dati, ang kolektor ng basura ay idinisenyo sa paraang gumagana ito sa parehong thread gaya ng iyong programa. At ayon sa ilang iskedyul, isang beses bawat ilang minuto, sinimulan nitong suriin ang pagkakaroon ng mga hindi kinakailangang bagay sa programa. Ang problema ay sa panahon ng pagsusuri at pagkolekta ng basura, ang programa ay nagyelo at hindi natupad. Isipin na nakaupo ka sa isang opisina na nagtatrabaho. Ngunit pagkatapos ay dumating ang isang naglilinis na babae at kailangang hugasan ang mga sahig sa silid. Pinaalis ka niya mula sa likod ng computer sa loob ng 5 minuto at maghihintay ka hanggang sa matapos siyang maglinis. Sa panahong ito hindi ka makakapagtrabaho. Ito ay halos kung paano gumagana ang mga kolektor ng basura noon :) Nang maglaon, binago ang mekanismong ito, at ngayon ay gumagana ang tagakolekta ng basura sa background, nang hindi nagpapabagal sa gawain ng mismong programa. Alam mo na na ang isang bagay ay namamatay kapag walang mga reference na natitira dito. Ngunit hindi talaga binibilang ng tagakolekta ng basura ang mga sanggunian sa . Una, maaari itong medyo mahaba. Pangalawa, hindi ito masyadong epektibo. Pagkatapos ng lahat, ang mga bagay ay maaaring sumangguni sa bawat isa! Ang figure ay nagpapakita ng isang halimbawa kung saan ang 3 bagay ay tumutukoy sa isa't isa, ngunit walang ibang nagre-reference sa kanila. Ibig sabihin, hindi sila kailangan para gumana ang natitirang bahagi ng programa. Kung ang tagakolekta ng basura ay nagbibilang lamang ng mga sanggunian, ang lahat ng 3 bagay na ito ay mananatili at hindi magpapalaya sa memorya: may mga sanggunian sa mga ito! Maihahalintulad ito sa isang spaceship. Sa panahon ng paglipad, nagpasya ang mga astronaut na suriin ang listahan ng mga ekstrang bahagi para sa pag-aayos at natagpuan sa kanila ang isang manibela at mga pedal mula sa isang ordinaryong kotse. Malinaw na hindi sila kailangan dito at kumukuha ng dagdag na espasyo. Bagaman ang mga bahaging ito ay konektado at may ilang mga pag-andar, sa loob ng balangkas ng pagpapatakbo ng spacecraft ang mga ito ay hindi kinakailangang basura, na mas mahusay na mapupuksa. Samakatuwid, nagpasya ang Java na gawin ang batayan para sa pagkolekta ng basura hindi pagbibilang ng mga sanggunian, ngunit paghahati ng mga bagay sa dalawang uri - maabot at hindi maabot.. Paano matukoy kung ang isang bagay ay naaabot? Lahat ng mapanlikha ay simple. Ang isang bagay ay maaabot kung ito ay isinangguni ng isa pang maabot na bagay. Nagreresulta ito sa isang "chain of reachability". Nagsisimula ito kapag nagsimula ang programa at nagpapatuloy sa buong tagal ng operasyon nito. Mukhang ganito: Ang arrow sa figure ay nagpapahiwatig ng executing code ng aming programa. Sa code, halimbawa sa pangunahing() na pamamaraan, ang mga sanggunian sa mga bagay ay nilikha. Ang mga bagay na ito ay maaaring tumukoy sa mga bagong bagay, sa mga iba pa, at iba pa. Isang hanay ng mga link ng bagay ay nabuo . Kung ang isang bagay ay maaaring maabot sa pamamagitan ng chain ng mga link na ito sa isang "root link," iyon ay, isa na direktang nilikha sa executing code, ito ay itinuturing na maaabot. Sa aming larawan sila ay ipinahiwatig sa asul. Ngunit kung ang isang bagay ay nahulog mula sa kadena na ito, iyon ay, wala sa mga variable sa code na kasalukuyang isinasagawa ang naglalaman ng mga sanggunian dito, at imposibleng maabot ito sa pamamagitan ng "kadena ng mga link" - ito ay itinuturing na hindi maabot. Sa aming programa, dalawang ganoong bagay ang ipinahiwatig sa pula. Pakitandaan: ang mga "pula" na bagay na ito ay may mga link sa isa't isa. Ngunit, tulad ng sinabi namin kanina, ang modernong kolektor ng basura sa Java ay hindi gumagawa ng pagbibilang ng sanggunian. Tinutukoy nito kung ang isang bagay ay maabot o hindi maabot . Samakatuwid, ang dalawang pulang bagay sa larawan ay magiging kanyang biktima. Ngayon tingnan natin ang buong proseso mula sa simula hanggang sa katapusan, at sa parehong oras tingnan natin kung paano gumagana ang memorya sa Java :) Lahat ng mga bagay sa Java ay naka-imbak sa isang espesyal na lugar ng memorya na tinatawag na heap . Sa karaniwang wika, ang isang "bunton" ay isang bundok ng mga bagay kung saan ang lahat ay nakahiga sa paligid na magkakagulo. Ngunit ang heap sa Java ay hindi ganoon. Ito ay may napaka-lohikal at makatwirang istraktura. Isang magandang araw, natuklasan ng mga programmer ng Java na ang lahat ng mga bagay sa kanilang mga programa ay maaaring hatiin sa dalawang uri - medyo nagsasalita, simpleng mga bagay at mga "mahabang buhay" . Ang mga bagay na "mahabang buhay" ay ang mga nakaligtas sa maraming koleksyon ng basura. Kadalasan ay mananatili sila hanggang sa katapusan ng programa. Bilang resulta, ang karaniwang heap, kung saan nakaimbak ang lahat ng nilikhang bagay, ay nahahati sa ilang bahagi. Ang unang bahagi ay may magandang pangalan - Eden (biblikal na "Hardin ng Eden"). Ito ay isang magandang pangalan dahil dito napupunta ang mga bagay pagkatapos nilang gawin. Nasa bahaging ito na ang memorya ay inilalaan para sa mga bagong bagay kapag nagsusulat tayonew. Maraming bagay ang maaaring gawin, at kapag naubusan ng espasyo sa lugar na ito, magsisimula ang una, "mabilis" na koleksyon ng basura. Dapat sabihin na ang kolektor ng basura ay napakatalino at pumipili ng isang algorithm ng trabaho depende sa kung ano ang higit pa sa bunton - basura o gumaganang mga bagay. Kung halos lahat ng mga bagay ay basura, minarkahan ng kolektor ang mga "live" na bagay at inililipat ang mga ito sa isa pang lugar ng memorya, pagkatapos nito ang kasalukuyang lugar ay ganap na nalinis. Kung kakaunti ang basura at karamihan dito ay inookupahan ng mga bagay na may buhay, minarkahan nito ang basura, nililinis ito, at inaayos ang mga natitirang bagay. Sinabi namin na "minarkahan ng kolektor ang "buhay" na mga bagay at inililipat ang mga ito sa isa pang lokasyon ng memorya, ngunit alin? Ang lugar ng memorya kung saan inililipat ang lahat ng bagay na hindi bababa sa isang koleksyon ng basura ay tinatawag na Survival Space . Ang Survival Space, naman, ay nahahati sa mga henerasyon . Ang bawat bagay ay itinalaga ng isang henerasyon batay sa kung gaano karaming mga koleksyon ng basura ang naranasan nito. Kung mayroon man, ito ay kabilang sa "Generation 1", kung 5 - sa "Generation 5". Magkasama, ang Eden at Survival Space ay bumubuo ng isang lugar na tinatawag na Young Generation . Bilang karagdagan sa Young Generation, mayroong isa pang memory area sa heap - Old Generation ("old generation"). Ito ang mga napakatagal na bagay na nakaligtas sa maraming koleksyon ng basura. Ito ay mas kumikita upang iimbak ang mga ito nang hiwalay mula sa lahat ng iba pa. At kapag puno na ang Old Generation area, i.e. Kahit na mayroong napakaraming pangmatagalang bagay sa programa na walang sapat na memorya, ang isang kumpletong koleksyon ng basura ay isinasagawa. Pinoproseso nito hindi lamang isang lugar ng memorya, ngunit sa pangkalahatan ang lahat ng mga bagay na nilikha ng Java machine. Natural, ito ay nangangailangan ng mas maraming oras at mapagkukunan. Iyon ang dahilan kung bakit napagpasyahan na mag-imbak ng mga pangmatagalang bagay nang hiwalay. Kapag naubusan ng espasyo sa ibang lugar, isinasagawa ang tinatawag na “mabilis na koleksyon ng basura”. Ito ay sumasaklaw lamang sa isang lugar, at dahil dito ito ay mas matipid at mas mabilis. Sa dulo, kapag ang lugar para sa mga centenarian ay barado na, ang buong paglilinis ay pumapasok sa away. Kaya, ang pinaka "mabigat" na tool ay ginagamit lamang ng assembler kapag hindi na kinakailangan. Sa eskematiko, ang istraktura ng heap at paglilinis ay ganito: