Vad är minnesallokering i Java? Stack och Heap Memory

Minnesallokering är en process genom vilken datorprogram och tjänster tilldelas fysiska eller virtuella minne Plats. I den här artikeln ska vi lära oss mer om allokering av minne i och vi kommer att diskutera Stack och Heap Memory.

• Vad är Stack Memory
• Viktiga funktioner i Stack Memory
• Metoder i Stack-klass
• Java-kod för stackimplementering
• Heap Space i Java
• Huvudfunktioner i Heap Memory
• Skillnad mellan Java Heap Space och Stack Memory
• Jämförelsediagram

Vad är Stack Memory?

Java Stack-minne används för körning av en tråd. De innehåller metodspecifika värden som är kortlivade och referenser till andra objekt i högen som hänvisas från metoden.

Stack minne refereras alltid till LIFO (Last-in-First-Out) ordning. Varje gång en metod åberopas skapas ett nytt block i stackminnet för att metoden ska hålla lokala primitiva värden och referens till andra objekt i metoden.

Så snart metoden slutar blir blocket oanvänt och blir tillgängligt för nästa metod.

split-funktion i java-exempel

Stackminnesstorleken är mycket mindre jämfört med Heap-minne.

Viktiga funktioner i Stack Memory

Bortsett från vad vi har diskuterat hittills följer några andra funktioner i Stack minne:

• Den växer och krymper när nya metoder anropas respektive returneras
• Variabler i stacken finns bara så länge som metoden som skapade dem körs
• Dess automatiskt allokeras och omplaceras när metoden är klar med körningen
• Om det här minnet är fullt kastar Java java.lang.StackOverFlowError
• Tillgång till detta minne är snabb jämfört med högminne
• Detta minne är trådsäker eftersom varje tråd fungerar i sin egen stack

Metoder i Stack-klass

• Objekt push ( Objektelement ): Skjuter ett element på toppen av stacken.
• Objektpop (): Tar bort och returnerar det övre elementet i stacken. Ett 'EmptyStackException' undantag kastas om vi kallar pop () när anropsstacken är tom.
• Objektkik (): Returnerar elementet på toppen av stacken, men tar inte bort det.
• Boolean tom (): Det blir sant om inget finns högst upp på stacken. Annars, returnerar falskt.
• int-sökning ( Objektelement ): Det avgör om ett objekt finns i stacken. Om elementet hittas returnerar det elementets position från toppen av stacken. Annars returnerar den -1.

Java-kod för stackimplementering

importera java.io. * importera java.util. * klass Testa {static void stack_push (Stack stack) {for (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) } } 

//Produktion

Nu, låt oss flytta in i Heap Space.

Heap Space i Java

Minnet tilldelas under genomförandet av instruktioner skrivna av programmerare. Observera att namnet heap inte har något att göra med heapdatastrukturen. Det kallas heap eftersom det är en hög med minne som är tillgänglig för programmerare tilldelats och avdela. Om en programmerare inte hanterar minnet bra kan ett minnesläckahända i programmet.

Viktiga funktioner i Java Heap Memory

• Bortsett från vad vi har diskuterat hittills, är några andra funktioner i högutrymme:
• Det nås via komplexa minneshanteringsmetoder som inkluderar Young Generation, Old eller Tenured Generation, och Permanent generation
• Om heaputrymmet är fullt, kastar Java java.lang.OutOfMemoryError
• Tillgången till detta minne är relativt långsammare än stackminnet
• Detta minne, till skillnad från stacken, omplaceras inte automatiskt. Det behöver Skräp samlare för att frigöra oanvända föremål så att minnesanvändningen blir effektivare
• Till skillnad från stack är det inte en hög trådsäker och måste skyddas genom korrekt synkronisering av koden

Skillnad mellan Java Heap Space och Stack Memory

Baserat på ovanstående förklaringar kan vi enkelt dra följande skillnader mellan Högen och Stack minne.

• Högen minne används av alla delar av applikationen medan stackminne endast används av en exekveringstråd.
• När ett objekt skapas lagras det alltid i Heap-utrymmet och stackminnet innehåller referensen till det. Stackminne innehåller bara lokala primitiva variabler och referensvariabler till föremål i högutrymme.
• Objekt som är lagrade i högen är globalt tillgängliga medan stackminne inte kan nås av andra trådar.
• Minneshantering i stacken sker i a LIFO sätt medan det är mer komplext i Heap-minne eftersom det används globalt. Högminnet är uppdelat i Ung generation, gammal generation etc, mer information på Java Garbage Collection.
• Stackminne är kortlivad medan heapminne lever från början till slutet av applikationens exekvering.
• Vi kan använda -XMX och -XMS JVM-alternativ för att definiera startstorlek och maximal storlek på heapminne. Vi kan använda -XSS för att definiera stackminnesstorleken.
• När stackminnet är fullt kastar Java runtime java.lang.StackOverFlowError medan om heapminnet är fullt, kastar det java.lang.OutOfMemoryError: Java Heap Spacefel.
• Stackminnesstorleken är mycket mindre jämfört med Heap-minne. På grund av enkelhet i minnesallokering (LIFO), stackminne är mycket snabbt jämfört medhögminne.

Jämförelsediagram

Med detta kommer vi till slutet av denna 'Memory Allocation in Java' -handledning. Jag hoppas att du har förstått konceptet och dess implementering genom några exempel i realtid.

Nu när du har förstått detMinnesallokering i Javagrunderna genom denna 'Memory Allocation in Java' -artikel, kolla in av Edureka, ett pålitligt online-lärande företag med ett nätverk av mer än 250 000 nöjda elever spridda över hela världen. Edurekas Java J2EE- och SOA-utbildnings- och certifieringskurser är utformade för studenter och yrkesverksamma som vill bli Java-utvecklare. Kursen är utformad för att ge dig ett försprång till Java-programmering och träna dig för både kärn- och avancerade Java-koncept tillsammans med olika Java-ramverk som Hibernate & Vår .

Har du en fråga till oss? Nämn det i kommentarsektionen i den här 'Memory Allocation in Java' -bloggen så kommer vi tillbaka till dig så snart som möjligt.