Hi! Sa palagay ko hindi ka masyadong magugulat kung sasabihin ko sa iyo na ang iyong computer ay may limitadong dami ng memorya :)
Kahit na ang iyong hard drive (na marami, maraming beses ang laki ng RAM) ay maaaring mapuno ng iyong mga paboritong laro, palabas sa TV, at iba pang mga bagay. Upang maiwasang mangyari ito, kailangan mong subaybayan ang kasalukuyang estado ng memorya ng iyong computer at tanggalin ang mga hindi kinakailangang file. Paano nauugnay ang lahat ng ito sa Java programming? Diretso lang! Pagkatapos ng lahat, ang paglikha ng anumang bagay ay nagiging sanhi ng paglalaan ng memorya ng Java machine para dito . Ang isang malaking real-world na programa ay lumilikha ng sampu o daan-daang libong mga bagay, at isang tipak ng memorya ang inilalaan para sa bawat isa sa kanila. Ngunit ano sa palagay mo, ilan sa mga bagay na ito ang umiiral? Sila ba ay "buhay" habang tumatakbo ang ating programa? Syempre hindi. Kahit na sa lahat ng kanilang mga pakinabang, ang mga bagay sa Java ay hindi imortal :) Ang mga bagay ay may sariling lifecycle. Ngayon ay magpahinga muna tayo sa pagsulat ng code at tuklasin ang prosesong ito :) Napakahalaga rin nito para maunawaan kung paano gumagana ang isang programa at para sa pamamahala ng mga mapagkukunan. Kaya, saan nagsisimula ang buhay ng isang bagay? Tulad ng isang tao, mula sa kapanganakan, ie kapag ito ay nilikha.
Una, ang Java virtual machine ay naglalaan ng memorya na kinakailangan upang lumikha ng bagay. Pagkatapos ay gagawa ito ng reference dito (sa aming kaso, cat) upang gawing posible na masubaybayan ito. Pagkatapos ang lahat ng mga variable ay sinisimulan, ang tagabuo ay tinatawag, at ang aming sariwang bagay ay nabubuhay na ngayon sa sarili nitong buhay :) Ang mga buhay ng bagay ay nag-iiba. Walang eksaktong mga numero dito. Sa anumang kaganapan, ang isang bagay ay naninirahan sa programa at gumaganap ng mga function nito sa loob ng ilang panahon. Upang maging tumpak, ang bagay ay "buhay" hangga't may mga sanggunian dito. Sa sandaling walang mga sanggunian, ang bagay ay "namamatay". Halimbawa:
public class Car {
String model;
public Car(String model) {
this.model = model;
}
public static void main(String[] args) {
Car lamborghini = new Car("Lamborghini Diablo");
lamborghini = null;
}
}
Sa main()pamamaraan, ang bagay na "Lamborghini Diablo" na Kotse ay hindi na nabubuhay sa pangalawang linya. Mayroon lamang isang reference dito, at ang reference ay itinakda sa null. Dahil walang natitirang mga sanggunian sa Diablo, ito ay nagiging "basura". Ang isang reference ay hindi kailangang itakda sa zero para mangyari ito:
public class Car {
String model;
public Car(String model) {
this.model = model;
}
public static void main(String[] args) {
Car lamborghini = new Car("Lamborghini Diablo");
Car lamborghiniGallardo = new Car("Lamborghini Gallardo");
lamborghini = lamborghiniGallardo;
}
}
Dito nakagawa kami ng pangalawang bagay at itinalaga ito sa sanggunian ng lamborghini. Ngayon, dalawang sanggunian ang tumuturo sa Lamborghini Gallardobagay, ngunit ang Lamborghini Diablobagay ay wala. Nangangahulugan ito na ang Diablobagay ay nagiging basura. Ito ay kapag nagsimula ang built-in na garbage collector (GC) ng Java .
Ang garbage collector ay isang panloob na mekanismo ng Java na responsable para sa pagpapalaya ng memorya, ibig sabihin, pag-alis ng mga hindi kinakailangang bagay mula sa memorya. May dahilan kung bakit pinili naming katawanin ito gamit ang isang robot vacuum cleaner. Gumagana ang tagakolekta ng basura sa halos parehong paraan: "ginagalaw" nito ang iyong programa sa background, nangongolekta ng basura. Halos hindi mo na kailangang makipag-ugnayan dito. Ang trabaho nito ay tanggalin ang mga bagay na hindi na ginagamit sa programa. Kaya, pinapalaya nito ang memorya para sa iba pang mga bagay. Naaalala mo ba na sa simula ng aralin sinabi namin sa totoong buhay kailangan mong subaybayan ang estado ng iyong computer at tanggalin ang mga lumang file? Kung pinag-uusapan natin ang mga bagay sa Java, ginagawa ito ng tagakolekta ng basura para sa iyo. Ang tagakolekta ng basura ay sinisimulan nang maraming beses habang tumatakbo ang iyong programa: hindi mo kailangang tahasang tawagan ito at bigyan ito ng mga utos (bagaman posible ito sa teknikal). Pag-uusapan pa natin ang tungkol sa basurero sa ibang pagkakataon at susuriin natin kung paano ito gumagana nang mas detalyado. Kapag naabot ng tagakolekta ng basura ang isang bagay—bago pa ito sirain—ang espesyal na finalize()pamamaraan ng bagay ay tinatawag. Ang pamamaraang ito ay maaaring gamitin upang ilabas ang ilang mga karagdagang mapagkukunan na ginagamit ng bagay. Ang finalize()pamamaraan ay kabilang sa klase ng Bagay. Sa madaling salita, ito ay katulad ng equals(), hashCode()at toString()(na dati mong nakilala). Ang bawat bagay ay mayroon nito . Ito ay naiiba sa iba pang mga pamamaraan sa na...paano natin ito sasabihin...ito ay lubos na sinasadya. Iyan ang ibig nating sabihinhindi ito palaging tinatawag bago ang isang bagay ay nawasak . Ang programming ay isang napaka-tumpak na aktibidad. Sinasabi ng programmer sa computer na gumawa ng isang bagay, at ginagawa ito ng computer. Ipinapalagay ko na nasanay ka na sa ganitong uri ng pag-uugali, kaya sa una ay maaaring mahirap para sa iyo na tanggapin ang sumusunod na ideya: "Bago masira ang isang bagay, ang pamamaraan ng klase ng Bagay ay tinatawag. O hindi. finalize()Kung tayo ay mapalad! " Gayunpaman, ito ay katotohanan. Ang Java machine mismo ang nagpapasiya kung tatawagan ang finalize() sa isang case by case basis. Bilang isang eksperimento, subukan nating patakbuhin ang sumusunod na code:
public class Cat {
private String name;
public Cat(String name) {
this.name = name;
}
public Cat() {
}
public static void main(String[] args) throws Throwable {
for (int i = 0 ; i < 1000000; i++) {
Cat cat = new Cat();
cat = null;// The first object becomes available for garbage collection here
}
}
@Override
protected void finalize() throws Throwable {
System.out.println("The Cat is destroyed!");
}
}
Lumilikha kami ng isang Catbagay, at sa susunod na linya ay i-zero out namin ang tanging sanggunian dito. At ginagawa namin iyon ng isang milyong beses. Tahasang na-override namin ang finalize()pamamaraan. Sa tuwing Catmasisira ang isang bagay, dapat itong magpakita ng string—kabuuang isang milyong beses. Pero hindi! Upang maging eksakto, sa aking computer ito ay naisakatuparan lamang ng 37346 na beses! Sa madaling salita, nagpasya ang aking Java machine na tawagan ang finalize()pamamaraan sa 1 lamang sa bawat 27 kaso. Sa ibang mga kaso, hindi kasama sa pagkolekta ng basura ang tawag na ito. Subukang patakbuhin ang code na ito sa iyong sarili. Malamang na makakakuha ka ng ibang resulta. Tulad ng nakikita mo, mahirap tumawag finalize()ng maaasahang kasosyo :) Kaya, narito ang isang maliit na tip para sa hinaharap: huwag umasa sa finalize()paraan upang maglabas ng mga kritikal na mapagkukunan.Maaaring tawagin ito ng JVM, o maaaring hindi. Sino ang nakakaalam? Kung ang iyong bagay ay may hawak na ilang mapagkukunang kritikal sa pagganap (halimbawa, isang bukas na koneksyon sa database) habang ito ay nabubuhay, mas mainam na gumawa at tahasang tumawag ng isang espesyal na paraan upang palabasin ang mga ito kapag ang bagay ay hindi na kailangan. Sa ganoong paraan, tiyak na malalaman mong hindi maghihirap ang pagganap ng iyong programa. Nagsimula kami sa pagsasabi na ang pagtatrabaho sa memorya at pagkolekta ng basura ay napakahalagang mga paksa, at totoo nga. Ang maling pangangasiwa ng mga mapagkukunan at hindi pagkakaunawaan kung paano nililinis ang mga hindi kinakailangang bagay ay maaaring humantong sa isa sa mga pinaka hindi kasiya-siyang bug: mga pagtagas ng memorya . Ito ay isa sa mga pinakakilalang error sa programming. Mayroon pa itong sariling artikulo sa Wikipedia. Ang hindi magandang nakasulat na code ay maaaring lumikha ng isang sitwasyon kung saan ang memorya ay inilalaan sa bawat oras para sa mga bagong likhang bagay, ngunit ang mga luma at hindi kinakailangang bagay ay hindi magagamit para sa koleksyon ng basura. Dahil nakagawa na kami ng robot vacuum cleaner analogy, isipin kung ano ang mangyayari kung bago patakbuhin ang robot ay nagkalat ka ng medyas sa buong bahay, nabasag ang isang glass vase, at nag-iwan ng mga piraso ng Lego sa sahig. Naturally, susubukan ng robot na gumawa ng isang bagay, ngunit isang araw ay sasakupin ito.
Para gumana nang maayos ang vacuum cleaner, kailangan mong panatilihing maayos ang sahig at kunin ang lahat ng hindi nito kayang hawakan. Ang tagakolekta ng basura ay sumusunod sa parehong prinsipyo. Kung ang isang programa ay may maraming bagay na hindi nito kayang linisin (tulad ng medyas o Lego para sa ating robotic vacuum cleaner), isang araw ay mauubusan tayo ng memorya. Hindi lamang mag-hang ang iyong programa, ang lahat ng iba pang mga program na nangyayari na tumatakbo sa computer ay magkakaroon din. Pagkatapos ng lahat, hindi rin sila magkakaroon ng sapat na memorya (bumalik sa aming pagkakatulad, ang basag na salamin sa sahig ay huminto hindi lamang sa vacuum cleaner, kundi pati na rin ang mga taong nakatira sa bahay). Sa madaling salita, ganito ang hitsura ng object lifecycle at koleksyon ng basura sa Java. Hindi mo kailangang kabisaduhin ito: sapat na upang maunawaan lamang kung paano ito gumagana. Sa susunod na aralin, babalik sa mga prosesong ito nang mas detalyado. Ngunit sa ngayon, maaari kang bumalik sa paglutas ng mga gawain sa CodeGym :) Good luck!
GO TO FULL VERSION