In Java, il heap è una regione di memoria utilizzata per l'allocazione dinamica della memoria. È dove vengono archiviati tutti gli oggetti Java (istanze di classi) e array. Non è * una struttura di dati come la struttura dei dati HEAP che potresti incontrare nei corsi di algoritmi (Min-heap, Max-Heap). È fondamentale capire quella distinzione.
Caratteristiche chiave di Java Heap:
1. Allocazione dinamica: La memoria per gli oggetti viene assegnata in fase di esecuzione, non di compilazione, se necessario. Non predefinire la dimensione esatta degli oggetti in anticipo.
2. Risorsa condivisa: Java Heap è una risorsa condivisa su tutti i thread all'interno di un JVM. Ciò significa che più thread possono accedere e modificare gli oggetti nell'heap. Sono necessari meccanismi di sincronizzazione (come blocchi, blocchi, blocchi, ecc.) Per gestire l'accesso simultaneo e prevenire la corruzione dei dati.
3. Collezione dei rifiuti: Il heap è gestito dal Java Garbage Collector (GC). Il GC rivendica automaticamente la memoria occupata da oggetti che non sono più raggiungibili (cioè non più citati da nessuna parte del programma). Ciò elimina la necessità di una gestione manuale della memoria come `malloc ()` e `free ()` in lingue come C ++.
4. Lifecycle oggetto: Gli oggetti vengono creati nel heap usando la parola chiave `new`. Risiedono nel mucchio fino a quando non diventano irraggiungibili e alla fine vengono raccolti dal GC.
5. La dimensione è regolabile: La dimensione del heap può essere configurata quando si avvia la macchina virtuale Java (JVM) utilizzando le opzioni della riga di comando come `-xms` (dimensione del heap iniziale) e` -xmx` (dimensione massima heap).
Come funziona il heap:
1. Creazione di oggetti: Quando si crea un nuovo oggetto usando `new`, JVM alloca la memoria per l'oggetto sul heap. I campi dell'oggetto vengono inizializzati in base alla definizione della classe.
`` `Java
class myclass {
int x;
Nome stringa;
}
Classe pubblica Main {
public static void main (string [] args) {
Myclass obj =new myclass (); // L'oggetto viene creato sul heap
obj.x =10;
obj.name ="esempio";
}
}
`` `
In questo esempio, `new myclass ()` alloca la memoria sul heap per un oggetto di tipo `myclass`. La variabile `obj` in` main` è un * riferimento * alla posizione di questo oggetto sul heap. Non è l'oggetto stesso, ma piuttosto un puntatore o indirizzo.
2. Riferimenti oggetto: Gli oggetti sono accessibili e manipolati attraverso riferimenti. Più riferimenti possono indicare lo stesso oggetto sul heap. Se tutti i riferimenti a un oggetto vengono persi (diventare null, uscire dall'ambito, ecc.), L'oggetto diventa irraggiungibile.
`` `Java
Myclass obj1 =new myclass ();
Myclass obj2 =obj1; // obj2 ora fa riferimento allo stesso oggetto di OBJ1
obj1 =null; // OBJ1 non fa più riferimento all'oggetto. Ma Obj2 lo fa ancora.
// L'oggetto MyClass è idoneo solo per la raccolta dei rifiuti quando OBJ2 diventa irraggiungibile.
`` `
3. Processo di raccolta della spazzatura:
* Analisi di raggiungibilità: Il GC determina quali oggetti sono ancora raggiungibili tracciando riferimenti a partire dagli oggetti di root (ad esempio, variabili locali in metodi attivi, variabili statiche).
* Contrassegna: Gli oggetti raggiungibili sono contrassegnati come "vivi".
* Spazzante/compattazione: Gli oggetti irraggiungibili vengono rimossi dall'heap. Alcuni algoritmi GC compattano anche il mucchio per ridurre la frammentazione.
4. Frammentazione del heap: Nel tempo, il mucchio può diventare frammentato, il che significa che la memoria libera è sparsa in blocchi piccoli e non contigui. Questo può rendere più difficile allocare oggetti di grandi dimensioni. Gli algoritmi GC spesso includono fasi di compattazione per consolidare la memoria libera.
5. Struttura heap (ipotesi generazionale): I GC moderni spesso dividono l'heap in generazioni in base all'ipotesi generazionale ", che afferma che la maggior parte degli oggetti ha una durata di vita breve. Il heap è in genere diviso in:
* Young Generation: Dove vengono creati nuovi oggetti. È ulteriormente diviso in:
* EDEN Space: Dove la maggior parte dei nuovi oggetti sono inizialmente assegnati.
* Survivor Spaces (S0, S1): Utilizzati per contenere oggetti che sono sopravvissuti a cicli GC minori.
* Old Generation (generazione di ruolo): Gli oggetti che sono sopravvissuti a più cicli GC nella giovane generazione sono promossi alla vecchia generazione.
* Generazione permanente (AMMENGEN - DOMPECATA IN Java 8, sostituita da Metaspace): Utilizzato per archiviare metadati di classe e altre informazioni statiche. (Nota importante:il amgen è stato sostituito da Metaspace in Java 8 e successivamente, che è assegnato dalla memoria nativa e non dal heap.)
L'approccio generazionale consente al GC di concentrare i suoi sforzi sulla giovane generazione, dove viene creata la maggior parte dei rifiuti.
Tuning heap:
La regolazione della dimensione del heap può avere un impatto significativo sulle prestazioni dell'applicazione.
* troppo piccolo: Frequenti cicli GC, portando a degradazione delle prestazioni e potenzialmente `outofmemoryerror`.
* troppo grande: Pause GC più lunghe, che influiscono sulla reattività.
È importante monitorare l'attività GC e regolare la dimensione del heap in base alle esigenze dell'applicazione. Strumenti come JConsole, VisualVM e Profilers possono aiutare in questo.
Differenze chiave dallo stack:
* heap: Utilizzato per l'allocazione dinamica degli oggetti. Condiviso tra i thread. Gestito da GC.
* Stack: Utilizzato per la memorizzazione di variabili locali e informazioni sulla chiamata del metodo. Specifico per il thread (ogni thread ha il suo stack). La memoria viene assegnata e trafficata in modo LIFO (per ultimo, primo out).
In sintesi:
Il heap Java è la regione di memoria dinamica in cui risiedono gli oggetti. Comprendere come funziona il heap, compresa la sua struttura, il ruolo del collettore della spazzatura e potenziali problemi come la frammentazione, è cruciale per scrivere applicazioni Java efficienti e robuste. La corretta dimensionamento del heap e la messa a punto GC sono essenziali per ottimizzare le prestazioni. Ricorda che è un'area di memoria gestita da JVM e * non * una struttura di dati heap.
Programmazione © www.354353.com