Ano ang Allocation ng Memory sa Java? Stack at Heap Memory

Paglalaan ng memorya ay isang proseso kung saan ang mga programa at serbisyo ng computer ay nakatalaga sa pisikal o virtual alaala space. Sa artikulong ito, malalaman natin ang tungkol sa paglalaan ng memorya sa at tatalakayin namin ang Stack at Heap Memory.

• Ano ang Memory ng Stack
• Pangunahing Mga Tampok ng Stack Memory
• Mga pamamaraan sa klase ng Stack
• Java code para sa pagpapatupad ng stack
• Heap Space sa Java
• Pangunahing Mga Tampok ng Heap Memory
• Pagkakaiba sa pagitan ng Java Heap Space at Stack Memory
• Tsart ng paghahambing

Ano ang Memory ng Stack?

Ang memorya ng Java Stack ay ginagamit para sa pagpapatupad ng isang thread. Naglalaman ang mga ito ng mga halagang partikular sa pamamaraan na panandalian at mga sanggunian sa iba pang mga bagay sa tambak na nakukuha mula sa pamamaraan.

Stack memorya ay laging isinangguni sa LIFO (Last-In-First-Out) umorder Tuwing ang isang pamamaraan ay tinawag, ang isang bagong bloke ay nilikha sa memorya ng stack para sa pamamaraan na humawak ng mga lokal na primitive na halaga at sumangguni sa iba pang mga bagay sa pamamaraan.

Sa sandaling matapos ang pamamaraan, ang block ay hindi nagamit at magagamit para sa susunod na pamamaraan.

bumuo ng random string sa java

Ang laki ng stack ng memorya ay mas mababa kumpara sa Heap memory.

Pangunahing Mga Tampok ng Stack Memory

Bukod sa tinalakay natin sa ngayon, ang sumusunod ay ilang iba pang mga tampok ng Stack memorya:

• Lumalaki ito at lumiliit habang ang mga bagong pamamaraan ay tinatawag at naibalik ayon sa pagkakabanggit
• Ang mga variable sa loob ng stack ay mayroon lamang hangga't tumatakbo ang pamamaraang lumikha sa kanila
• Ito ay awtomatiko inilaan at nakipagpalitan kapag natapos ng pamamaraan ang pagpapatupad
• Kung ang memorya na ito ay puno na, ang Java ay nagtatapon java.lang.StackOverFlowError
• Ang pag-access sa memorya na ito ay mabilis kung ihahambing sa memorya ng magbunton
• Ang memorya na ito ay ligtas na sinulid habang ang bawat thread ay nagpapatakbo sa sarili nitong stack

Mga pamamaraan sa klase ng Stack

• Object push ( Elemento ng object ): Itinutulak ang isang elemento sa tuktok ng stack.
• Object pop (): Tanggalin at ibabalik ang nangungunang elemento ng stack. Isang 'EmptyStackException' itinatapon ang pagbubukod kung tumatawag kami ng pop () kapag ang invoking stack ay walang laman.
• Silip ng object (): Ibinabalik ang elemento sa tuktok ng stack, ngunit hindi ito alisin.
• Walang laman ang Boolean (): Ito ay babalik totoo kung wala sa tuktok ng stack. Iba pa, nagbabalik ng hindi totoo.
• int paghahanap ( Elemento ng object ): Tinutukoy nito kung mayroong isang bagay sa stack. Kung ang elemento ay natagpuan, ibabalik nito ang posisyon ng elemento mula sa tuktok ng stack. Iba pa, nagbabalik ito -1.

Java code para sa pagpapatupad ng stack

import java.io. * import java.util. * class Test {static void stack_push (Stack stack) {para sa (int i = 0 i<5 i++){ stack.push(i) } } static void stack_pop(Stack stack){ System.out.println('Pop :') for(int i = 0 i < 5 i++){ Integer y = (Integer) stack.pop() System.out.println(y) } } static void stack_peek(Stack stack){ Integer element = (Integer) stack.peek() System.out.println('Element on stack top : ' + element) } static void stack_search(Stack stack, int element){ Integer pos = (Integer) stack.search(element) if(pos == -1) System.out.println('Element not found') else System.out.println('Element is found at position ' + pos) } public static void main (String[] args){ Stack stack = new Stack() stack_push(stack) stack_pop(stack) stack_push(stack) stack_peek(stack) stack_search(stack, 2) stack_search(stack, 6) } } 

// Output

Ngayon, Lumipat tayo sa Heap Space.

Heap Space sa Java

Ang memorya ay inilalaan sa panahon ng pagpapatupad ng mga tagubilin na isinulat ng mga programmer. Tandaan na ang pangalan ng bunton ay walang kinalaman sa istraktura ng data ng magbunton. Ito ay tinatawag na bunton dahil ito ay isang tumpok ng memorya ng puwang na magagamit sa mga programmer na inilaan at de-ilaan. Kung ang isang programmer ay hindi hawakan nang maayos ang memorya na ito, maaari ang isang tagas ng memoryamangyari sa programa.

Pangunahing Mga Tampok ng Java Heap Memory

• Bukod sa tinalakay natin sa ngayon, ang sumusunod ay ilang iba pang mga tampok ng heap space:
• Na-access ito sa pamamagitan ng mga komplikadong diskarte sa pamamahala ng memorya na kasama Young Generation, Matanda o Tenured Generation, at Permanenteng Henerasyon
• Kung ang heap space ay puno, ang Java throws java.lang.OutOfMemoryError
• Ang pag-access sa memorya na ito ay medyo mas mabagal kaysa sa memorya ng stack
• Ang memorya na ito, sa kaibahan sa stack, ay hindi awtomatikong napalitan. Kailangan nito Basurero upang palayain ang mga hindi nagamit na bagay upang mapanatili ang kahusayan ng paggamit ng memorya
• Hindi tulad ng stack, isang tambak ay hindi ligtas na sinulid at kailangang mabantayan sa pamamagitan ng maayos na pagsabay sa code

Pagkakaiba sa pagitan ng Java Heap Space at Stack Memory

Batay sa mga paliwanag sa itaas, madali nating mahihinuha ang mga sumusunod na pagkakaiba sa pagitan Tambak at Stack alaala

• Tambak ang memorya ay ginagamit ng lahat ng mga bahagi ng application samantalang ang stack memory ay ginagamit lamang ng isang thread ng pagpapatupad.
• Kailan man nilikha ang isang bagay, palaging nakaimbak ito sa puwang ng Heap at naglalaman ng sanggunian dito ang stack memory. Naglalaman lamang ang stack memory mga lokal na variable ng primitive at mga variable na sanggunian sa mga bagay sa heap space.
• Ang mga bagay na nakaimbak sa bunton ay naa-access sa buong mundo samantalang ang memorya ng stack ay hindi ma-access ng iba pang mga thread.
• Ang pamamahala ng memorya sa stack ay tapos na sa a LIFO sa paraang paraan habang mas kumplikado ito sa memorya ng Heap dahil ginagamit ito sa buong mundo. Ang memorya ng tambak ay nahahati sa Batang Henerasyon, Lumang Henerasyon atbp, higit pang mga detalye sa Java Garbage Collection.
• Ang stack memory ay panandalian samantalang ang tambak ng memorya ay nabubuhay mula sa simula hanggang sa katapusan ng pagpapatupad ng aplikasyon.
• Pwede natin gamitin -XMX at -XMS Ang pagpipilian ng JVM upang tukuyin ang laki ng pagsisimula at maximum na laki ng memorya ng magbunton. Pwede natin gamitin -XSS upang tukuyin ang laki ng stack memory.
• Kapag puno ang stack memory, nagtatapon ang Java runtime java.lang.StackOverFlowError samantalang kung puno ng puno ng alaala, ito ay nagtatapon java.lang.OutOfMemoryError: Java Heap Spacekamalian
• Napakaliit ng laki ng stack ng memorya kung ihahambing sa memorya ng Heap. Dahil sa pagiging simple sa paglalaan ng memorya (LIFO), ang memory ng stack ay napakabilis kung ihahambing samagbunton ng memorya.

Tsart ng paghahambing

Sa pamamagitan nito, natapos namin ang Tutorial na 'Alokasyon sa Memory sa Java' na Tutorial. Inaasahan kong naiintindihan mo ang konsepto at ang pagpapatupad nito sa pamamagitan ng ilang mga halimbawa ng real-time.

Ngayon na naintindihan moPaglalaan ng Memory sa Javamga pangunahing kaalaman sa pamamagitan ng artikulong 'Memory Allocation in Java' na suriin ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Ang mga kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer. Ang kurso ay dinisenyo upang bigyan ka ng isang panimula sa pag-program ng Java at sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring .

May tanong ba sa amin? Nabanggit ito sa seksyon ng mga puna ng 'Alokasyong Memorya sa Java' na blog at babalikan ka namin sa lalong madaling panahon.