Опитвам се да разбера какви са концепциите за млади, стари и постоянни поколения в терминологията на Java heap и по-конкретно взаимодействията между трите поколения.
Въпросите ми са:
Това изглежда като често срещано недоразумение. В JVM на Oracle постоянното генериране не е част от купчината. Това е отделно пространство за дефиниции на класове и свързани данни. В Java 6 и по-рано, интернираните низове също се съхраняват в постоянното генериране. В Java 7 интернираните низове се съхраняват в основния обем на обекта.
Ето една добра публикация за постоянно поколение.
Харесвам описанията, дадени за всяко пространство в ръководството на Oracle за JConsole:
За HotSpot Java VM пуловете памет за серийно събиране на отпадъци са следните.
- Eden Space (купчина): Пулът, от който първоначално се разпределя памет за повечето обекти.
- Survivor Space (купчина): Басейнът, съдържащ обекти, които са оцелели след събирането на боклука в пространството Eden.
- Tenured Generation (купчина): Пулът, съдържащ обекти, които са съществували известно време в пространството на оцелелите.
- Постоянно генериране (без купчина): Пулът, съдържащ всички отразяващи данни на самата виртуална машина, като обекти на клас и метод. С Java VM, които използват споделяне на данни от клас, това поколение е разделено на области само за четене и области за четене и запис.
- Кодов кеш (без купчина): HotSpot Java VM също включва кодов кеш, съдържащ памет, която се използва за компилиране и съхранение на естествен код.
Java използва поколение събиране на отпадъци. Това означава, че ако имате обект foo (който е екземпляр на някакъв клас), колкото повече събития за събиране на боклук оцелява (ако все още има препратки към него), толкова повече се повишава. Започва в младото поколение (което само по себе си е разделено на множество пространства - Eden и Survivor) и в крайна сметка ще завърши в поколението с наем, ако оцелее достатъчно дълго.
Грамадата е разделена на млади и стари поколения, както следва:
Младо поколение: Това е място, където е живяно за кратък период от време и разделено на две пространства:
Старо поколение: Този басейн основно съдържа наемно и виртуално (резервирано) пространство и ще съхранява тези обекти, които са оцелели след събирането на боклука от Young Generation.
Постоянно генериране: Този пул памет, както казва името, съдържа постоянни метаданни за клас и информация за дескриптори, така че пространството в PermGen винаги е запазено за класове и тези, които са свързани с класовете, например статични членове.
Актуализация на Java8: PermGen се заменя с Metaspace, което е много подобно.
Основната разлика е, че Metaspace преоразмерява динамично, т.е. разширяване по време на изпълнение.
Java Metaspace пространство: неограничено (по подразбиране)
Кеш на код (виртуален или запазен): Ако използвате HotSpot Java VM, това включва област на кеша на кода, която съдържа памет, която ще се използва за компилиране и съхранение на собствен код.
Какво е младото поколение?
Младото поколение е мястото, където всички нови обекти се разпределят и остаряват. Когато младото поколение се напълни, това води до незначително събиране на боклука. Много бързо се събира младо поколение, пълно с мъртви предмети. Някои оцелели предмети са остарели и в крайна сметка преминават към старото поколение.
Какво е старото поколение?
Старото поколение се използва за съхраняване на отдавна оцелели обекти. Обикновено се задава праг за обект от младо поколение и когато тази възраст бъде достигната, обектът се премества към старото поколение. В крайна сметка старото поколение трябва да бъде събрано. Това събитие се нарича основно събиране на отпадъци
Какво представлява постоянното поколение?
Постоянното генериране съдържа метаданни, изисквани от JVM за описание на класовете и методите, използвани в приложението. Постоянното генериране се попълва от JVM по време на изпълнение въз основа на класове, използвани от приложението.
PermGen е заменен с Metaspace след издаването на Java 8.
Параметрите PermSize & MaxPermSize сега ще бъдат игнорирани
Как трите поколения си взаимодействат/отнасят едно към друго?
Източник на изображение и статия с урок за Oracle Technetwork: http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
„Общият процес на събиране на боклук“ в горната статия обяснява взаимодействията между тях с много диаграми.
Разгледайте обобщената диаграма:
Виртуалната машина на Java е организирана в три поколения: младо поколение, старо поколение и постоянно поколение. Повечето обекти първоначално се разпределят в младото поколение. Старото поколение съдържа предмети, които са оцелели в колекциите на младото поколение, както и някои големи обекти, които могат да бъдат разпределени директно в старото поколение. Постоянното генериране съдържа обекти, които JVM намира за удобни за управление на събирача на отпадъци, като обекти, описващи класове и методи, както и самите класове и методи.
Паметта в SunHotSpot JVM е организирана в три поколения: младо поколение, старо поколение и постоянно поколение.
FYI: Постоянното поколение не се счита за част от Java heap.
Как трите поколения взаимодействат/свързват едно с друго? Обектите (с изключение на големите) първо се разпределят към младото поколение. Ако даден обект остане жив след x no. на циклите за събиране на боклука, той се повишава до стария/щатен ген. Следователно можем да кажем, че младият ген съдържа краткотрайните обекти, докато старият ген съдържа обектите с дълъг живот. Постоянният ген не взаимодейства с другите две поколения.
