Memoria într-un program C/C++/Java poate fi alocată fie pe o stivă, fie pe un heap.
Condiție preliminară: Dispunerea memoriei programului C .

Alocarea stivei: Alocarea are loc pe blocuri adiacente de memorie. O numim o alocare de memorie stivă, deoarece alocarea are loc în stiva de apeluri de funcție. Mărimea memoriei care trebuie alocată este cunoscută de compilator și ori de câte ori o funcție este apelată, variabilele acesteia primesc memorie alocată pe stivă. Și ori de câte ori apelul de funcție se încheie, memoria variabilelor este de-alocată. Toate acestea se întâmplă folosind niște rutine predefinite în compilator. Un programator nu trebuie să-și facă griji cu privire la alocarea memoriei și dezalocarea variabilelor stivei. Acest tip de alocare a memoriei este cunoscut și sub denumirea de alocare temporară a memoriei deoarece, de îndată ce metoda își termină execuția, toate datele care aparțin acelei metode sunt eliminate automat din stivă. Aceasta înseamnă că orice valoare stocată în schema de memorie a stivei este accesibilă atâta timp cât metoda nu și-a încheiat execuția și este în prezent într-o stare de rulare.

Selenium tutorial java

Puncte cheie:

• Este o schemă temporară de alocare a memoriei în care membrii datelor sunt accesibile numai dacă metoda ( ) care i-a conținut rulează în prezent.
• Acesta alocă sau de-aloca memoria automat de îndată ce metoda corespunzătoare își finalizează execuția.
• Primim eroarea corespunzătoare Java. lang. StackOverFlowError de JVM , Dacă memoria stivei este plină complet.
• Alocarea memoriei stivei este considerată mai sigură în comparație cu alocarea memoriei heap, deoarece datele stocate pot fi accesate numai de către firul proprietar.
• Alocarea și dezalocarea memoriei sunt mai rapide în comparație cu alocarea memoriei heap.
• Memoria stivă are mai puțin spațiu de stocare în comparație cu memoria Heap.

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

Alocare heap: Memoria este alocată în timpul execuției instrucțiunilor scrise de programatori. Rețineți că grămada de nume nu are nimic de-a face cu pierdere de memorie se poate întâmpla în program.

Alocarea memoriei heap este împărțită în trei categorii: - Aceste trei categorii ne ajută să prioritizăm datele (Obiectele) care urmează să fie stocate în memoria Heap sau în Colectarea gunoiului .

dezavantajele serviciilor bancare online

• Generatia tanara - Este porțiunea din memorie în care sunt făcute toate datele (obiectele) noi pentru a aloca spațiul și ori de câte ori această memorie este complet umplută, restul datelor sunt stocate în Garbage collection.
• Generație veche sau titulară - Aceasta este partea din Heap-memory care conține obiectele de date mai vechi care nu sunt utilizate frecvent sau nu sunt utilizate deloc.
• Generație permanentă - Aceasta este porțiunea din Heap-memory care conține metadatele JVM-ului pentru clasele de rulare și metodele de aplicare.

Puncte cheie:

• Primim mesajul de eroare corespunzător dacă spațiul heap este complet plin, java. lang.OutOfMemoryError de JVM.
• Această schemă de alocare a memoriei este diferită de alocarea spațiului stivă, aici nu este furnizată nicio caracteristică de de-alocare automată. Trebuie să folosim un colector de gunoi pentru a elimina vechile obiecte neutilizate pentru a folosi memoria eficient.
• Timpul de procesare (timp de acces) al acestei memorie este destul de lent în comparație cu memoria stivă.
• De asemenea, memoria heap nu este la fel de sigură pentru fire ca și Stack-memory, deoarece datele stocate în heap-memory sunt vizibile pentru toate firele.
• Dimensiunea memoriei Heap este destul de mai mare în comparație cu memoria Stack.
• Memoria heap este accesibilă sau există atâta timp cât rulează întreaga aplicație (sau programul java).

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

Exemplu amestecat de ambele tipuri de alocare de memorie Heap și Stack în 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>

Iată concluziile pe care le vom face după analiza exemplului de mai sus:

• Pe măsură ce începem execuția programului have, toate clasele de rulare sunt stocate în spațiul de memorie Heap.
• Apoi găsim metoda main() în linia următoare care este stocată în stivă împreună cu toate primitivele (sau locale) ale acesteia și variabila de referință Emp de tip Emp_detail va fi, de asemenea, stocată în stivă și va indica obiectul corespunzător. stocate în memoria Heap.
• Apoi, următoarea linie va apela constructorul parametrizat Emp(int, String) din main() și, de asemenea, va fi alocată în partea de sus a aceluiași bloc de memorie stivă. Aceasta va stoca:
  • Referința obiectului obiectului invocat al memoriei stivei.
  • Valoarea primitivă ( Variabila de referință a argumentului String emp_name va indica șirul real din pool-ul de șiruri în memoria heap.
• Apoi metoda principală va apela din nou metoda statică Emp_detail(), pentru care alocarea se va face în blocul de memorie stivă deasupra blocului de memorie anterior.
• Variabila de referință a argumentului String emp_name va indica șirul real din pool-ul de șiruri în memoria heap.

Variabila de referință a argumentului String emp_name va indica șirul real din pool-ul de șiruri în memoria heap.

Fig.1

js înlocuitor

Diferențele cheie între alocările de stivă și heap

1. Într-o stivă, alocarea și de-alocarea sunt efectuate automat de către compilator, în timp ce, în heap, trebuie făcute manual de programator.
2. Manipularea cadrului stivei este mai costisitoare decât manipularea cadrului stivei.
3. Problema deficitului de memorie este mai probabil să se întâmple în stivă, în timp ce principala problemă în memoria heap este fragmentarea.
4. Accesul la cadrele stivei este mai ușor decât cadrul heap, deoarece stiva are o regiune mică de memorie și este prietenoasă cu memoria cache, dar în cazul cadrelor heap care sunt dispersate în memorie, provoacă mai multe pierderi de memorie cache.
5. O stivă nu este flexibilă, dimensiunea memoriei alocată nu poate fi modificată, în timp ce un heap este flexibil, iar memoria alocată poate fi modificată.
6. Accesarea timpului de stocare în heap este mai mult decât o stivă.

Diagramă de comparație

Parametru	GRĂMADĂ	MORMAN
De bază	Memoria este alocată într-un bloc contiguu.	Memoria este alocată în orice ordine aleatorie.
Alocarea și dezalocarea	Automat prin instrucțiunile compilatorului.	Manual de la programator.
Cost	Mai puțin	Mai mult
Implementarea	Uşor	Greu
Timpul de acces	Mai repede	Mai lent
Problema principala	Lipsa memoriei	Fragmentarea memoriei
Localitatea de referință	Excelent	Adecvat
Siguranță	Thread safe, datele stocate pot fi accesate numai de proprietar	Nu este sigur pentru fire, datele stocate sunt vizibile pentru toate firele
Flexibilitate	Marime fixa	Redimensionarea este posibilă
Structura tipului de date	Liniar	Ierarhic
Preferat	Alocarea statică a memoriei este preferată într-o matrice.	Alocarea memoriei heap este preferată în lista legată.
mărimea	Mai mică decât memoria grămadă.	Mai mare decât memoria stivei.