hög i Java:Dynamic Memory Allocation
I Java, heap är en minnesregion som används för dynamisk minnesallokering. Det är där alla Java -objekt (instanser av klasser) och matriser lagras. Det är * inte * en datastruktur som HEAP-datastrukturen du kan stöta på i algoritmerskurser (min-heap, max-heap). Det är avgörande att förstå den distinktionen.
Nyckelegenskaper för Java -högen:
1. dynamisk allokering: Minne för objekt tilldelas vid körning, inte sammanställningstid, efter behov. Du förde inte den exakta storleken på objekt i förväg.
2. delad resurs: Java Heap är en delad resurs över alla trådar inom en JVM. Detta innebär att flera trådar kan komma åt och ändra objekt i högen. Synkroniseringsmekanismer (som "synkroniserade" block, lås etc.) är nödvändiga för att hantera samtidig åtkomst och förhindra datakorruption.
3. sopor samling: Högen hanteras av Java Garbage Collector (GC). GC återvinner automatiskt minnet som ockuperas av objekt som inte längre kan nås (dvs. inte längre refereras av någon del av programmet). Detta eliminerar behovet av manuell minneshantering som `malloc ()` och `gratis ()` på språk som C ++.
4. Objekt Livscykel: Objekt skapas i högen med hjälp av det "nya" nyckelordet. De bor i högen tills de blir oåtkomliga och så småningom samlas in av GC.
5. Storlek är justerbar: Storleken på högen kan konfigureras när Java Virtual Machine (JVM) startar med kommandoradsalternativ som `-xms` (initial högstorlek) och` -xmx` (maximal högstorlek).
Hur högen fungerar:
1. Objektskapande: När du skapar ett nytt objekt med "NYTT" tilldelar JVM -minnet för objektet på högen. Objektets fält initialiseras enligt klassdefinitionen.
`` `Java
klass MyClass {
int x;
Strängnamn;
}
public class Main {
public static void main (String [] args) {
MyClass obj =new MyClass (); // objekt skapas på högen
obj.x =10;
obj.name ="exempel";
}
}
`` `
I det här exemplet tilldelar "ny MyClass ()" minne på högen för ett objekt av typen "MyClass". Variabeln "OBJ" i "huvud" är en * referens * till detta objekts plats på högen. Det är inte själva objektet, utan snarare en pekare eller adress.
2. Objektreferenser: Objekt nås och manipuleras genom referenser. Flera referenser kan peka på samma objekt på högen. Om alla hänvisningar till ett objekt går förlorade (bli noll, gå ut ur räckvidd etc.) blir objektet oåtkomligt.
`` `Java
MyClass obj1 =new MyClass ();
MyClass Obj2 =obj1; // obj2 hänvisar nu till samma objekt som obj1
obj1 =null; // obj1 hänvisar inte längre till objektet. Men obj2 gör det fortfarande.
// MyClass -objektet är endast berättigat till skräpuppsamling när obj2 också blir oåtkomlig.
`` `
3. sopor insamlingsprocess:
* Analys av nåhet: GC bestämmer vilka objekt som fortfarande kan nås genom att spåra referenser från rotobjekt (t.ex. lokala variabler i aktiva metoder, statiska variabler).
* Marking: Räckbara föremål markeras som "levande".
* svepning/komprimering: Oåtkomliga föremål tas bort från högen. Vissa GC -algoritmer kompakterar också högen för att minska fragmenteringen.
4. heap -fragmentering: Med tiden kan högen bli fragmenterad, vilket innebär att fritt minne är spridda i små, icke-kontinuerliga block. Detta kan göra det svårare att fördela stora föremål. GC -algoritmer inkluderar ofta komprimeringsfaser för att konsolidera fritt minne.
5. högstruktur (generationshypotes): Moderna GC:er delar ofta högen i generationer baserat på "generationshypotesen", som säger att de flesta föremål har korta livslängd. Högen är vanligtvis uppdelad i:
* ung generation: Där nya objekt skapas. Det är vidare uppdelat i:
* Eden Space: Där de flesta nya objekt initialt tilldelas.
* Survivor Spaces (S0, S1): Används för att hålla föremål som har överlevt mindre GC -cykler.
* Old Generation (Tenured Generation): Objekt som har överlevt flera GC -cykler i den unga generationen befordras till den gamla generationen.
* permanent generation (Permgen - Avskriven i Java 8, ersatt av metaspace): Används för att lagra klassmetadata och annan statisk information. (Viktig anmärkning:Permgen har ersatts av metaspace i Java 8 och senare, som tilldelas från infödda minne och inte högen.)
Generationsmetoden gör det möjligt för GC att fokusera sina ansträngningar på den unga generationen, där de flesta skräp skapas.
heap -inställning:
Att justera högstorleken kan påverka applikationsprestanda avsevärt.
* för liten: Frekventa GC -cykler, vilket leder till prestandaförstöring och potentiellt `outofmemoryError '.
* för stort: Längre GC pausar, påverkar lyhördhet.
Det är viktigt att övervaka GC -aktivitet och justera högstorleken baserad på applikationsbehov. Verktyg som JConsole, VisualVM och profiler kan hjälpa till med detta.
Nyckelskillnader från stacken:
* hög: Används för dynamisk fördelning av objekt. Delas över trådar. Hanteras av GC.
* stack: Används för att lagra lokala variabler och metodsamtalinformation. Trådspecifik (varje tråd har sin egen stack). Minnet tilldelas och återförsäljas på ett LIFO (sist-in, först) sätt.
Sammanfattningsvis:
Java -högen är det dynamiska minnesregionen där föremål bor. Att förstå hur högen fungerar, inklusive dess struktur, rollen för skräpsamlaren och potentiella problem som fragmentering, är avgörande för att skriva effektiva och robusta Java -applikationer. Korrekt högstorlek och GC -inställning är viktiga för att optimera prestanda. Kom ihåg att det är ett minnesområde som hanteras av JVM och * inte * en HEAP -datastruktur.
