Minne i et C/C++/Java-program kan enten tildeles på en stack eller en haug.
Forutsetning: Minneoppsett av C-program .

Stakktildeling: Tildelingen skjer på sammenhengende minneblokker. Vi kaller det en stabelminneallokering fordi allokeringen skjer i funksjonskallstakken. Størrelsen på minnet som skal tildeles er kjent for kompilatoren, og hver gang en funksjon kalles, får variablene dens minne tildelt på stabelen. Og hver gang funksjonskallet er over, blir minnet for variablene deallokert. Alt dette skjer ved å bruke noen forhåndsdefinerte rutiner i kompilatoren. En programmerer trenger ikke å bekymre seg for minneallokering og deallokering av stabelvariabler. Denne typen minneallokering er også kjent som midlertidig minneallokering, fordi så snart metoden fullfører sin utførelse, skylles alle dataene som tilhører den metoden automatisk ut av stabelen. Dette betyr at enhver verdi som er lagret i stabelminneskjemaet er tilgjengelig så lenge metoden ikke har fullført utførelsen og for øyeblikket kjører.

maur vs maven

Viktige punkter:

• Det er et midlertidig minnetildelingsskjema der datamedlemmene bare er tilgjengelige hvis metoden ( ) som inneholdt dem kjører.
• Den tildeler eller de-allokerer minnet automatisk så snart den tilsvarende metoden fullfører utførelsen.
• Vi får den tilsvarende feilmeldingen Java. lang. StackOverFlowError av JVM , Hvis stabelminnet er helt fylt.
• Stakkminneallokering anses som tryggere sammenlignet med heapminnetildeling fordi dataene som er lagret kun kan nås av eiertråden.
• Minnetildeling og deallokering er raskere sammenlignet med heap-minneallokering.
• Stack-minne har mindre lagringsplass sammenlignet med Heap-minne.

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

Heap-tildeling: Minnet tildeles under utførelsen av instruksjoner skrevet av programmerere. Merk at navnehaugen ikke har noe å gjøre med hukommelsestap kan skje i programmet.

Heap-minnetildelingen er videre delt inn i tre kategorier:- Disse tre kategoriene hjelper oss med å prioritere data(objekter) som skal lagres i heap-minnet eller i Søppelsamling .

analysere streng til int

• Ung generasjon – Det er den delen av minnet der alle de nye dataene (objektene) er laget for å tildele plassen, og hver gang dette minnet er helt fylt, lagres resten av dataene i søppelsamling.
• Gammel eller fast generasjon – Dette er den delen av Heap-memory som inneholder de eldre dataobjektene som ikke er i hyppig bruk eller ikke er i bruk i det hele tatt, er plassert.
• Permanent generasjon – Dette er delen av Heap-minne som inneholder JVMs metadata for kjøretidsklassene og applikasjonsmetoder.

Viktige punkter:

• Vi mottar den tilsvarende feilmeldingen hvis Heap-space er helt fullt, java. lang.OutOfMemoryError av JVM.
• Dette minneallokeringsskjemaet er forskjellig fra Stack-space-allokeringen, her er ingen automatisk deallokeringsfunksjon gitt. Vi må bruke en søppelsamler for å fjerne de gamle ubrukte gjenstandene for å kunne bruke minnet effektivt.
• Behandlingstiden (tilgangstiden) til dette minnet er ganske treg sammenlignet med Stack-minne.
• Heap-minne er heller ikke så gjengesikkert som Stack-minne fordi data som er lagret i Heap-minne er synlige for alle tråder.
• Størrelsen på Heap-minnet er ganske større sammenlignet med Stack-minnet.
• Heap-minne er tilgjengelig eller eksisterer så lenge hele applikasjonen (eller java-programmet) kjører.

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

Blandet eksempel på begge typer minneallokering Heap og 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ølgende er konklusjonene vi vil trekke etter å ha analysert eksemplet ovenfor:

tilfeldig tallgenerator i c

• Når vi starter kjøringen av ha-programmet, lagres alle kjøretidsklassene i Heap-minneområdet.
• Så finner vi main()-metoden i neste linje som er lagret i stabelen sammen med alle dens primitive(eller lokale) og referansevariabelen Emp av typen Emp_detail vil også bli lagret i stabelen og vil peke ut til det tilsvarende objektet lagret i heap-minnet.
• Deretter vil neste linje kalle til den parameteriserte konstruktøren Emp(int, String) fra main( ), og den vil også allokeres til toppen av den samme stabelminneblokken. Dette vil lagre:
  • Objektreferansen til det påkalte objektet i stabelminnet.
  • Den primitive verdien( Referansevariabelen til String emp_name-argumentet vil peke til den faktiske strengen fra strengpoolen inn i heap-minnet.
• Deretter vil hovedmetoden igjen kalle til den statiske metoden Emp_detail(), som allokering vil bli gjort i stabelminneblokken på toppen av forrige minneblokk.
• Referansevariabelen til String emp_name-argumentet vil peke til den faktiske strengen fra strengpoolen inn i heap-minnet.

Referansevariabelen til String emp_name-argumentet vil peke til den faktiske strengen fra strengpoolen inn i heap-minnet.

Figur 1

Nøkkelforskjeller mellom stabel- og heapallokeringer

1. I en stabel gjøres tildelingen og deallokeringen automatisk av kompilatoren, mens det i en haug må gjøres av programmereren manuelt.
2. Håndtering av Heap-rammen er dyrere enn å håndtere stabelrammen.
3. Problem med minnemangel er mer sannsynlig å oppstå i stabelen, mens hovedproblemet i heap-minne er fragmentering.
4. Stackframe-tilgang er enklere enn heap-rammen ettersom stabelen har et lite minneområde og er cache-vennlig, men når det gjelder heap-rammer som er spredt over hele minnet, forårsaker det flere cache-misser.
5. En stabel er ikke fleksibel, minnestørrelsen som er tildelt kan ikke endres, mens en haug er fleksibel, og det tildelte minnet kan endres.
6. Å få tilgang til tiden for heap tar er mer enn en stabel.

Sammenligningsskjema

Parameter	STABLE	HEAP
Grunnleggende	Minne er allokert i en sammenhengende blokk.	Minne tildeles i tilfeldig rekkefølge.
Allokering og De-allokering	Automatisk ved kompilatorinstruksjoner.	Manual av programmereren.
Koste	Mindre	Mer
Gjennomføring	Lett	Hard
Tilgangstid	Raskere	Langsommere
Hoved problemet	Mangel på hukommelse	Minnefragmentering
Referansested	Utmerket	Tilstrekkelig
Sikkerhet	Trådsikker, data som er lagret kan bare nås av eieren	Ikke trådsikker, data som er lagret er synlig for alle tråder
Fleksibilitet	Fast størrelse	Det er mulig å endre størrelse
Datatypestruktur	Lineær	Hierarkisk
Foretrukket	Statisk minneallokering foretrekkes i en matrise.	Heap-minnetildeling foretrekkes i den koblede listen.
Størrelse	Lite minne enn haug.	Større enn stabelminne.