Siklo ng buhay ng bagay

Kamusta! Sa palagay ko hindi ka masyadong magugulat kung sasabihin namin sa iyo na ang laki ng memorya sa iyong computer ay limitado :) Kahit na ang isang hard drive, na maraming beses na mas malaki kaysa sa RAM, ay maaaring punan sa kapasidad ng iyong mga paboritong laro, serye sa TV, at iba pa. Upang maiwasang mangyari ito, kailangan mong subaybayan ang kasalukuyang estado ng memorya at tanggalin ang mga hindi kinakailangang file mula sa iyong computer. Ano ang kinalaman ng Java programming sa lahat ng ito? Direkta! Pagkatapos ng lahat, kapag ang anumang bagay ay nilikha ng Java machine, ang memorya ay inilalaan para dito. Sa isang tunay na malaking programa, sampu at daan-daang libong mga bagay ang nilikha, na ang bawat isa ay may sariling piraso ng memorya na inilalaan. Ngunit gaano katagal sa tingin mo ang lahat ng mga bagay na ito ay umiiral? "Nabubuhay" ba sila sa buong oras na tumatakbo ang aming programa? Siyempre hindi. Sa lahat ng mga pakinabang ng mga bagay sa Java, hindi sila imortal :) Ang mga bagay ay may sariling ikot ng buhay. Ngayon ay kukuha kami ng kaunting pahinga mula sa pagsulat ng code at titingnan ang prosesong ito :) Bukod dito, napakahalaga para sa pag-unawa sa pagpapatakbo ng programa at pamamahala ng mga mapagkukunan. Kaya, saan nagsisimula ang buhay ng isang bagay? Tulad ng isang tao - mula sa kanyang kapanganakan, iyon ay, paglikha.

Cat cat = new Cat();//вот сейчас и начался vital цикл нашего an object Cat!

Una, ang Java Virtual Machine ay naglalaan ng kinakailangang halaga ng memorya upang malikha ang bagay. Pagkatapos ay gagawa siya ng link dito, sa aming kaso - catupang masubaybayan ito. Pagkatapos nito, ang lahat ng mga variable ay sinisimulan, ang constructor ay tinatawag, at narito, ang aming sariwang bagay ay nabubuhay na sa sarili nitong buhay :) Iba ang habang-buhay ng mga bagay, walang eksaktong mga numero dito. Sa anumang kaso, sa loob ng ilang oras nabubuhay ito sa loob ng programa at gumaganap ng mga function nito. Upang maging tumpak, ang isang bagay ay "buhay" hangga't may mga sanggunian dito. Sa sandaling walang natitirang mga link, 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 pamamaraan, main()ang Lamborghini Diablo car object ay tumigil na sa pagiging buhay na nasa pangalawang linya. Mayroon lamang isang link dito, at ngayon ang link na ito ay naitalaga na null. Dahil walang mga reference na natitira sa Lamborghini Diablo, ito ay nagiging "junk". Hindi kinakailangang i-reset ang link:

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 lumikha kami ng pangalawang bagay, pagkatapos ay kinuha namin ang sanggunian lamborghiniat itinalaga ito sa bagong bagay na ito. Mayroon na ngayong Lamborghini Gallardodalawang sanggunian sa bagay, ngunit Lamborghini Diablowala sa bagay. Samakatuwid ang bagay Diabloay nagiging basura. At sa sandaling ito, gumagana ang built-in na mekanismo ng Java na tinatawag na garbage collector, o sa madaling salita - Garbage Collector, GC. Ang kolektor ng basura ay isang panloob na mekanismo ng Java na responsable para sa pagpapalaya ng memorya, iyon ay, pag-alis ng mga hindi kinakailangang bagay mula dito. Ito ay hindi para sa wala na pinili namin ang isang larawan na may isang robot vacuum cleaner upang ilarawan ito. Pagkatapos ng lahat, ang tagakolekta ng basura ay gumagana sa halos parehong paraan: sa background, ito ay "naglalakbay" sa iyong programa, nangongolekta ng basura, at sa parehong oras ay halos hindi ka nakikipag-ugnayan dito. Ang trabaho nito ay alisin ang mga bagay na hindi na ginagamit sa programa. Kaya, pinapalaya nito ang memorya sa computer para sa iba pang mga bagay. Naaalala mo ba sa simula ng panayam na sinabi namin na sa ordinaryong buhay kailangan mong subaybayan ang estado ng iyong computer at tanggalin ang mga lumang file? Kaya, sa kaso ng mga bagay sa Java, ginagawa ito ng tagakolekta ng basura para sa iyo. Ang Garbage Collector ay inilunsad nang maraming beses sa panahon ng pagpapatakbo ng iyong programa: hindi ito kailangang tawaging partikular at bigyan ng mga utos, bagama't ito ay posible sa teknikal. Mamaya ay pag-uusapan natin ang higit pa tungkol dito at pag-aralan ang proseso ng trabaho nito nang mas detalyado. Sa sandaling naabot ng kolektor ng basura ang bagay, bago ang pagkawasak nito, isang espesyal na paraan ang tinatawag sa bagay - finalize(). Maaari itong magamit upang magbakante ng ilang karagdagang mapagkukunan na ginagamit ng bagay. Ang pamamaraan finalize()ay kabilang sa klase Object. Ibig sabihin, kasama ng equals(), hashCode()at toString(), na nakilala mo na kanina, mayroon nito ang anumang bagay. Ang pagkakaiba nito sa ibang mga pamamaraan ay ito ay... kung paano ilagay ito... napaka-kapritsoso. Ibig sabihin, hindi ito palaging tinatawag bago sirain ang isang bagay. Ang programming ay isang tiyak na bagay. Sinasabi ng programmer sa computer na gumawa ng isang bagay, at ginagawa ito ng computer. Marahil ay nasanay ka na sa ganitong pag-uugali, at maaaring mahirap para sa iyo sa simula na tanggapin ang ideya: “Bago sirain ang mga bagay, ang pamamaraan finalize()ng klase ay tinatawag na Object. O hindi ito tinatawag. Kung susuwertehin tayo!" Gayunpaman, ito ay totoo. Ang Java machine mismo ang nagpapasiya kung tatawagan ang pamamaraan finalize()sa bawat partikular na kaso o hindi. Halimbawa, subukan nating patakbuhin ang sumusunod na code para sa eksperimento:

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;//вот здесь первый an object становится доступен сборщику мусора
       }
   }

   @Override
   protected void finalize() throws Throwable {
       System.out.println("Объект Cat уничтожен!");
   }
}

Lumilikha kami ng isang bagay Catat sa susunod na linya ng code ay ni-reset namin ang tanging reference dito. At kaya - isang milyong beses. Tahasang na-override namin ang method finalize(), at dapat nitong i-print ang string sa console ng isang milyong beses, sa bawat oras bago sirain ang object Cat. Pero hindi! Upang maging tumpak, tumakbo lamang ito ng 37,346 beses sa aking computer! Iyon ay, sa 1 kaso lamang sa 27 ang Java machine na na-install ko ay nagpasya na tumawag ng isang paraan finalize()- sa ibang mga kaso, ang koleksyon ng basura ay nagpatuloy nang wala ito. Subukang patakbuhin ang code na ito sa iyong sarili: malamang, mag-iiba ang resulta. Tulad ng nakikita mo, finalize()mahirap tawagan itong isang maaasahang kasosyo :) Samakatuwid, isang maliit na payo para sa hinaharap: hindi ka dapat umasa sa pamamaraan finalize()sa kaso ng pagpapalaya ng ilang mga kritikal na mapagkukunan. Baka ang JVM ang tatawag dito, baka hindi. Sino ang nakakaalam? Kung sa panahon ng kanyang buhay ang iyong bagay ay sumasakop ng ilang mga mapagkukunan na sobrang mahalaga para sa pagganap, halimbawa, ito ay nagpapanatili ng isang bukas na koneksyon sa database, mas mahusay na lumikha ng isang espesyal na paraan sa iyong klase upang palayain ang mga ito at tawagan ito nang malinaw kapag ang bagay ay hindi na kailangan. Sa ganitong paraan malalaman mong tiyak na hindi maghihirap ang pagganap ng iyong programa. Sa simula pa lang sinabi namin na ang pamamahala ng memorya at pag-alis ng basura ay napakahalaga, at totoo ito. Ang hindi wastong pangangasiwa ng mga mapagkukunan at kawalan ng pag-unawa sa proseso ng pag-assemble ng mga hindi kinakailangang bagay ay maaaring humantong sa mga pagtagas ng memorya. Ito ay isa sa mga pinakatanyag na pagkakamali sa programming. Ang maling pagkakasulat ng code ng programmer ay maaaring magresulta sa bagong memorya na inilalaan sa bawat oras para sa mga bagong likhang bagay, habang ang mga luma at hindi kinakailangang bagay ay hindi magagamit para sa pagtanggal ng basurero. Dahil gumawa kami ng pagkakatulad sa isang robot vacuum cleaner, isipin kung ano ang mangyayari kung, bago simulan ang robot, nagkalat ka ng mga medyas sa paligid ng bahay, nabasag ang isang glass vase at nag-iwan ng disassembled Lego set sa sahig. Ang robot, siyempre, ay susubukan na gumawa ng isang bagay, ngunit sa isang punto ay makaalis ito. Para gumana ito ng maayos, kailangan mong panatilihing nasa mabuting kondisyon ang sahig at alisin ang lahat mula doon na hindi kayang hawakan ng vacuum cleaner. Gumagana ang tagakolekta ng basura sa parehong prinsipyo. Kung mayroong maraming bagay na natitira sa programa na hindi nito makolekta (tulad ng isang medyas o Lego para sa isang robot vacuum cleaner), sa isang punto ay mauubos ang memorya. At hindi lamang ang program na iyong isinulat ay mag-freeze, kundi pati na rin ang lahat ng iba pang mga program na tumatakbo sa computer sa sandaling iyon. Hindi rin magkakaroon ng sapat na memorya para sa kanila. Ito ang hitsura ng object life cycle at garbage collector sa Java. Hindi na kailangang kabisaduhin ito: kailangan mo lamang na maunawaan ang prinsipyo ng pagpapatakbo. Sa susunod na panayam ay pag-uusapan natin ang mga prosesong ito nang mas detalyado, ngunit sa ngayon maaari kang bumalik sa paglutas ng mga problema sa JavaRush :) Good luck!