Minne i ett C/C++/Java-program kan antingen allokeras på en stack eller en heap.
Nödvändig förutsättning: Minneslayout för C-program .

Stacktilldelning: Tilldelningen sker på sammanhängande minnesblock. Vi kallar det en stackminnestilldelning eftersom allokeringen sker i funktionsanropsstacken. Storleken på minnet som ska allokeras är känd för kompilatorn och närhelst en funktion anropas får dess variabler minne allokerat på stacken. Och närhelst funktionsanropet är över avallokeras minnet för variablerna. Allt detta sker med några fördefinierade rutiner i kompilatorn. En programmerare behöver inte oroa sig för minnesallokering och avallokering av stackvariabler. Denna typ av minnesallokering är också känd som Temporär minnesallokering eftersom så snart metoden avslutar sin exekvering spolas all data som tillhör den metoden automatiskt ut från stacken. Detta innebär att alla värden som är lagrade i stackminnesschemat är tillgängliga så länge som metoden inte har slutfört sin exekvering och för närvarande är i driftläge.

kolla efter null i java

Nyckelord:

• Det är ett temporärt minnesallokeringsschema där datamedlemmarna endast är tillgängliga om metoden( ) som innehöll dem körs.
• Den allokerar eller avallokerar minnet automatiskt så fort motsvarande metod slutför sin exekvering.
• Vi får motsvarande fel Java. lang. StackOverFlowError förbi JVM , Om stackminnet är helt fyllt.
• Stackminnestilldelning anses vara säkrare jämfört med heapminnestilldelning eftersom lagrad data endast kan nås av ägartråden.
• Minnesallokering och -deallokering är snabbare jämfört med Heap-minnestilldelning.
• Stackminne har mindre lagringsutrymme jämfört med Heap-minne.

int main() {  // All these variables get memory  // allocated on stack  int a;  int b[10];  int n = 20;  int c[n]; }>

Högtilldelning: Minnet tilldelas under exekveringen av instruktioner skrivna av programmerare. Observera att namnhögen inte har något att göra med minnesförlust kan hända i programmet.

Heap-memory allokeringen är vidare uppdelad i tre kategorier:- Dessa tre kategorier hjälper oss att prioritera data(objekt) som ska lagras i Heap-minnet eller i Skräp samling .

vilka månader finns i Q3

• Ung generation - Det är den del av minnet där all ny data (objekt) görs för att allokera utrymmet och närhelst detta minne är helt fyllt lagras resten av data i Garbage Collection.
• Gammal eller fastställd generation – Detta är den del av Heap-memory som innehåller de äldre dataobjekt som inte är i frekvent användning eller inte används alls placeras.
• Permanent generation – Detta är den del av Heap-minnet som innehåller JVM:s metadata för körtidsklasserna och applikationsmetoderna.

Nyckelord:

• Vi får motsvarande felmeddelande om Heap-space är helt fullt, java. lang.OutOfMemoryError av JVM.
• Detta minnesallokeringsschema skiljer sig från Stack-space-allokeringen, här tillhandahålls ingen automatisk avallokeringsfunktion. Vi måste använda en garbage collector för att ta bort de gamla oanvända föremålen för att kunna använda minnet effektivt.
• Bearbetningstiden (åtkomsttiden) för detta minne är ganska långsam jämfört med Stack-minne.
• Heap-minne är inte heller lika trådsäkert som Stack-memory eftersom data som lagras i Heap-memory är synliga för alla trådar.
• Storleken på Heap-minnet är ganska större jämfört med Stack-minnet.
• Högminne är tillgängligt eller existerar så länge hela applikationen (eller java-programmet) körs.

int main() {  // This memory for 10 integers  // is allocated on heap.  int *ptr = new int[10]; }>

Blandat exempel på båda typerna av minnesallokering Heap och Stack i java:

#include  using namespace std; int main() {  int a = 10; // stored in stack  int* p = new int(); // allocate memory in heap  *p = 10;  delete (p);  p = new int[4]; // array in heap allocation  delete[] p;  p = NULL; // free heap  return 0; }>

class Emp {  int id;  String emp_name;  public Emp(int id, String emp_name) {  this.id = id;  this.emp_name = emp_name;  } } public class Emp_detail {  private static Emp Emp_detail(int id, String emp_name) {  return new Emp(id, emp_name);  }  public static void main(String[] args) {  int id = 21;  String name = 'Maddy';  Emp person_ = null;  person_ = Emp_detail(id, name);  } }>

def main(): a = 10 # stored in stack p = None # declaring p variable p = 10 # allocating memory in heap del p # deleting memory allocation in heap p = [None] * 4 # array in heap allocation p = None # free heap return 0 if __name__ == '__main__': main()>

// Define the Emp class with id and emp_name properties class Emp {  constructor(id, emp_name) {  this.id = id; // Initialize id  this.emp_name = emp_name; // Initialize emp_name  } } // Create an instance of the Emp class const person = new Emp(21, 'Maddy'); // Initialize person with id 21 and emp_name 'Maddy' console.log(person); // Output the person object to the console>

Följande är slutsatserna som vi kommer att dra efter att ha analyserat exemplet ovan:

javascript utskrift

• När vi börjar köra har-programmet, lagras alla körtidsklasser i Heap-minnesutrymmet.
• Sedan hittar vi main()-metoden på nästa rad som är lagrad i stacken tillsammans med alla dess primitiva (eller lokala) och referensvariabeln Emp av typen Emp_detail kommer också att lagras i Stacken och pekar ut mot motsvarande objekt lagras i Heap-minnet.
• Sedan kommer nästa rad att anropa den parametriserade konstruktorn Emp(int, String) från main( ) och den kommer också att allokeras till toppen av samma stackminnesblock. Detta kommer att lagra:
  • Objektreferensen för det anropade objektet i stackminnet.
  • Det primitiva värdet ( Referensvariabeln för String emp_name-argumentet pekar på den faktiska strängen från strängpoolen till högminnet.
• Då kommer huvudmetoden återigen att anropa den statiska metoden Emp_detail(), för vilken allokering kommer att göras i stackminnesblocket ovanpå det föregående minnesblocket.
• Referensvariabeln för String emp_name-argumentet pekar på den faktiska strängen från strängpoolen till högminnet.

Referensvariabeln för String emp_name-argumentet pekar på den faktiska strängen från strängpoolen till högminnet.

Figur 1

Nyckelskillnader mellan stack- och heapallokering

1. I en stack görs tilldelningen och avallokeringen automatiskt av kompilatorn, medan det i högen måste göras av programmeraren manuellt.
2. Att hantera Heap-ramen är dyrare än att hantera stapelramen.
3. Problem med minnesbrist är mer sannolikt att hända i stack medan huvudproblemet i heap-minne är fragmentering.
4. Stackramsåtkomst är enklare än heapramen eftersom stacken har en liten minnesregion och är cache-vänlig men i fallet med heapframes som är spridda över hela minnet så att det orsakar fler cachemissar.
5. En stack är inte flexibel, den tilldelade minnesstorleken kan inte ändras medan en hög är flexibel och det tilldelade minnet kan ändras.
6. Att komma åt tiden för heap tar är mer än en stack.

Jämförelsediagram

Parameter	STACK	HÖGEN
Grundläggande	Minnet allokeras i ett angränsande block.	Minnet tilldelas i valfri slumpmässig ordning.
Tilldelning och avfördelning	Automatisk av kompilatorinstruktioner.	Manual av programmeraren.
Kosta	Mindre	Mer
Genomförande	Lätt	Hård
Åtkomsttid	Snabbare	Långsammare
Huvudproblem	Brist på minne	Minnesfragmentering
Referensort	Excellent	Lämplig
Säkerhet	Trådsäker, lagrad data kan endast nås av ägaren	Inte trådsäker, data som lagras är synlig för alla trådar
Flexibilitet	Fixad storlek	Det går att ändra storlek
Datatypstruktur	Linjär	Hierarkisk
Föredraget	Statisk minnesallokering är att föredra i en array.	Heap-minnestilldelning är att föredra i den länkade listan.
Storlek	Litet minne än högt.	Större än stackminne.