Pag-unawa sa Memorya sa JVM
Tulad ng alam mo na, ang JVM ay nagpapatakbo ng mga programang Java sa loob mismo nito. Tulad ng anumang virtual machine, mayroon itong sariling sistema ng organisasyon ng memorya.
Ang layout ng panloob na memorya ay nagpapahiwatig kung paano gumagana ang iyong Java application. Sa ganitong paraan, matutukoy ang mga bottleneck sa pagpapatakbo ng mga application at algorithm. Tingnan natin kung paano ito gumagana.
Mahalaga! Ang orihinal na modelo ng Java ay hindi sapat, kaya ito ay binago sa Java 1.5. Ang bersyon na ito ay ginagamit hanggang ngayon (Java 14+).
Thread Stack
Ang modelo ng memorya ng Java na ginamit sa loob ng JVM ay naghahati ng memorya sa mga thread stack at tambak. Tingnan natin ang modelo ng memorya ng Java, lohikal na nahahati sa mga bloke:
Ang lahat ng mga thread na tumatakbo sa JVM ay may sariling stack . Ang stack, sa turn, ay nagtataglay ng impormasyon tungkol sa kung aling mga pamamaraan ang tinawag ng thread. Tatawagin ko itong "call stack". Magpapatuloy ang call stack sa sandaling maisagawa ng thread ang code nito.
Ang stack ng thread ay naglalaman ng lahat ng mga lokal na variable na kinakailangan upang magsagawa ng mga pamamaraan sa stack ng thread. Maa-access lang ng thread ang sarili nitong stack. Ang mga lokal na variable ay hindi nakikita ng ibang mga thread, tanging sa thread na lumikha sa kanila. Sa isang sitwasyon kung saan dalawang thread ang nagpapatupad ng parehong code, pareho silang gumagawa ng sarili nilang mga lokal na variable. Kaya, ang bawat thread ay may sariling bersyon ng bawat lokal na variable.
Ang lahat ng lokal na variable ng mga primitive na uri ( boolean , byte , short , char , int , long , float , double ) ay ganap na nakaimbak sa thread stack at hindi nakikita ng ibang mga thread. Ang isang thread ay maaaring magpasa ng kopya ng isang primitive na variable sa isa pang thread, ngunit hindi makakapagbahagi ng primitive na lokal na variable.
Bunton
Ang heap ay naglalaman ng lahat ng mga bagay na ginawa sa iyong application, anuman ang thread na lumikha ng bagay. Kabilang dito ang mga wrapper ng mga primitive na uri (halimbawa, Byte , Integer , Long , at iba pa). Hindi mahalaga kung ang bagay ay nilikha at itinalaga sa isang lokal na variable o nilikha bilang isang miyembro ng variable ng isa pang bagay, ito ay naka-imbak sa heap.
Nasa ibaba ang isang diagram na naglalarawan ng call stack at mga lokal na variable (sila ay naka-imbak sa mga stack) pati na rin ang mga bagay (sila ay naka-imbak sa heap):
Sa kaso kung saan ang lokal na variable ay isang primitive na uri, ito ay naka-imbak sa thread ng stack.
Ang isang lokal na variable ay maaari ding maging sanggunian sa isang bagay. Sa kasong ito, ang reference (lokal na variable) ay naka-imbak sa thread stack, ngunit ang object mismo ay naka-imbak sa heap.
Ang isang bagay ay naglalaman ng mga pamamaraan, ang mga pamamaraang ito ay naglalaman ng mga lokal na variable. Ang mga lokal na variable na ito ay nakaimbak din sa thread stack, kahit na ang object na nagmamay-ari ng pamamaraan ay naka-store sa heap.
Ang mga variable ng miyembro ng isang bagay ay iniimbak sa heap kasama ang mismong bagay. Ito ay totoo kapwa kapag ang variable ng miyembro ay isang primitive na uri at kapag ito ay isang object reference.
Ang mga static na variable ng klase ay iniimbak din sa heap kasama ang kahulugan ng klase.
Pakikipag-ugnayan sa mga bagay
Ang mga bagay sa heap ay maaaring ma-access ng lahat ng mga thread na may reference sa object. Kung ang isang thread ay may access sa isang bagay, maaari nitong ma-access ang mga variable ng object. Kung ang dalawang thread ay tumawag sa isang paraan sa parehong bagay sa parehong oras, pareho silang magkakaroon ng access sa mga variable ng miyembro ng object, ngunit ang bawat thread ay magkakaroon ng sarili nitong kopya ng mga lokal na variable.
Ang dalawang thread ay may hanay ng mga lokal na variable.Lokal na Variable 2tumuturo sa isang nakabahaging bagay sa heap (Bagay 3). Ang bawat isa sa mga thread ay may sariling kopya ng lokal na variable na may sariling sanggunian. Ang kanilang mga sanggunian ay mga lokal na variable at samakatuwid ay naka-imbak sa mga thread stack. Gayunpaman, dalawang magkaibang reference ang tumuturo sa parehong bagay sa heap.
Mangyaring tandaan na ang heneralBagay 3may mga link saBagay 2AtBagay 4bilang mga variable ng miyembro (ipinapakita ng mga arrow). Sa pamamagitan ng mga link na ito, maaaring ma-access ng dalawang threadBagay 2AtBagay4.
Ang diagram ay nagpapakita rin ng isang lokal na variable (lokal na variable 1mula sa methodTwo ). Ang bawat kopya nito ay naglalaman ng magkakaibang mga sanggunian na tumuturo sa dalawang magkaibang bagay (Bagay 1AtBagay 5) at hindi pareho. Theoretically, parehong maa-access ng mga thread ang parehoBagay 1, kaya saBagay 5kung mayroon silang mga sanggunian sa parehong mga bagay na ito. Ngunit sa diagram sa itaas, ang bawat thread ay may reference lamang sa isa sa dalawang bagay.
Isang halimbawa ng pakikipag-ugnayan sa mga bagay
Tingnan natin kung paano natin maipapakita ang gawain sa code:
public class MySomeRunnable implements Runnable() {
public void run() {
one();
}
public void one() {
int localOne = 1;
Shared localTwo = Shared.instance;
//... do something with local variables
two();
}
public void two() {
Integer localOne = 2;
//... do something with local variables
}
}public class Shared {
// store an instance of our object in a variable
public static final Shared instance = new Shared();
// member variables pointing to two objects on the heap
public Integer object2 = new Integer(22);
public Integer object4 = new Integer(44);
}Ang run() method ay tumatawag sa one() method , at one() naman ay tumatawag ng two() .
Ang one() method ay nagdedeklara ng primitive local variable (localOne) ng uri int at isang lokal na variable (localTwo), na isang sanggunian sa isang bagay.
Ang bawat thread na nagsasagawa ng one() na pamamaraan ay gagawa ng sarili nitong kopyalocalOneAtlocalTwosa iyong stack. Mga variablelocalOneay ganap na mahihiwalay sa isa't isa, na nasa stack ng bawat thread. Hindi makita ng isang thread kung ano ang mga pagbabagong ginagawa ng isa pang thread sa kopya nitolocalOne.
Ang bawat thread na nagsasagawa ng one() na pamamaraan ay lumilikha din ng sarili nitong kopyalocalTwo. Gayunpaman, dalawang magkaibang kopyalocalTwonagtatapos sa pagturo sa parehong bagay sa heap. Sa katotohanan aylocalTwotumuturo sa bagay na tinutukoy ng static na variablehalimbawa. Mayroon lamang isang kopya ng isang static na variable, at ang kopya na iyon ay nakaimbak sa heap.
Kaya parehong kopyalocalTwonagtatapos sa pagturo sa parehong Shared instance . Naka-store din ang Shared instance sa heap. MagkatugmaBagay 3sa diagram sa itaas.
Tandaan na ang Shared class ay naglalaman din ng dalawang variable ng miyembro. Ang mga variable ng miyembro mismo ay naka-imbak sa heap kasama ang bagay. Dalawang miyembrong variable ang tumuturo sa dalawa pang bagayInteger. Ang mga integer na bagay na ito ay tumutugma saBagay 2AtBagay 4sa diagram.
Tandaan din na ang two() method ay lumilikha ng lokal na variable na pinangalananlocalOne. Ang lokal na variable na ito ay isang reference sa isang object ng uri ng Integer . Ang pamamaraan ay nagtatakda ng linklocalOneupang tumuro sa isang bagong Integer instance . Ang link ay maiimbak sa kopya nitolocalOnepara sa bawat thread. Dalawang Integer instance ang maiimbak sa heap, at dahil ang paraan ay lumilikha ng bagong Integer object sa tuwing ito ay isasagawa, ang dalawang thread na nagsasagawa ng paraang ito ay lilikha ng magkahiwalay na Integer instance . Magkatugma silaBagay 1AtBagay 5sa diagram sa itaas.
Pansinin din ang dalawang variable ng miyembro sa Shared class na uri ng Integer , na isang primitive na uri. Dahil ang mga variable na ito ay mga variable ng miyembro, nakaimbak pa rin ang mga ito sa heap kasama ang object. Ang mga lokal na variable lamang ang nakaimbak sa thread stack.