How is the java memory pool divided

Question

I   m currently monitoring a Java application with jconsole  The memory tab lets you choose between   Heap Memory Usage Non-Heap Memory Usage Memory Pool    Eden Space    Memory Pool    Survivor Space    Memory Pool    Tenured Gen    Memory Pool    Code Cache    Memory Pool    Perm Gen      What is the difference between them

User · Accepted Answer

Heap memory

The heap memory is the runtime data area from which the Java VM allocates memory for all class instances and arrays. The heap may be of a fixed or variable size. The garbage collector is an automatic memory management system that reclaims heap memory for objects.

Eden Space: The pool from which memory is initially allocated for most objects.
Survivor Space: The pool containing objects that have survived the garbage collection of the Eden space.
Tenured Generation or Old Gen: The pool containing objects that have existed for some time in the survivor space.

Non-heap memory

Non-heap memory includes a method area shared among all threads and memory required for the internal processing or optimization for the Java VM. It stores per-class structures such as a runtime constant pool, field and method data, and the code for methods and constructors. The method area is logically part of the heap but, depending on the implementation, a Java VM may not garbage collect or compact it. Like the heap memory, the method area may be of a fixed or variable size. The memory for the method area does not need to be contiguous.

Permanent Generation: The pool containing all the reflective data of the virtual machine itself, such as class and method objects. With Java VMs that use class data sharing, this generation is divided into read-only and read-write areas.
Code Cache: The HotSpot Java VM also includes a code cache, containing memory that is used for compilation and storage of native code.

Here's some documentation on how to use Jconsole.

User · Answer

Java Heap Memory is part of memory allocated to JVM by Operating System   Objects reside in an area called the heap  The heap is created when the JVM starts up and may increase or decrease in size while the application runs  When the heap becomes full  garbage is collected     You can find more details about Eden Space  Survivor Space  Tenured Space and Permanent Generation in below SE question   Young   Tenured and Perm generation  PermGen has been replaced with Metaspace since Java 8 release   Regarding your queries    Eden Space  Survivor Space  Tenured Space are part of heap memory Metaspace and Code Cache are part of non-heap memory    Codecache  The Java Virtual Machine  JVM  generates native code and stores it in a memory area called the codecache  The JVM generates native code for a variety of reasons  including for the dynamically generated interpreter loop  Java Native Interface  JNI  stubs  and for Java methods that are compiled into native code by the just-in-time  JIT  compiler  The JIT is by far the biggest user of the codecache

User · Answer

The new keyword allocates memory on the Java heap  The heap is the main pool of memory  accessible to the whole of the application  If there is not enough memory available to allocate for that object  the JVM attempts to reclaim some memory from the heap with a garbage collection  If it still cannot obtain enough memory  an OutOfMemoryError is thrown  and the JVM exits  The heap is split into several different sections  called generations  As objects survive more garbage collections  they are promoted into different generations  The older generations are not garbage collected as often  Because these objects have already proven to be longer lived  they are less likely to be garbage collected  When objects are first constructed  they are allocated in the Eden Space  If they survive a garbage collection  they are promoted to Survivor Space  and should they live long enough there  they are allocated to the Tenured Generation  This generation is garbage collected much less frequently  There is also a fourth generation  called the Permanent Generation  or PermGen  The objects that reside here are not eligible to be garbage collected  and usually contain an immutable state necessary for the JVM to run  such as class definitions and the String constant pool  Note that the PermGen space is planned to be removed from Java 8  and will be replaced with a new space called Metaspace  which will be held in native memory  reference http   www programcreek com 2013 04 jvm-run-time-data-areas

User · Answer

With Java8  non heap region no more contains PermGen but Metaspace  which is a major change in Java8  supposed to get rid of out of memory errors with java as metaspace size can be increased depending on the space required by jvm for class data

User · Answer

The Heap is divided into young and old generations as follows   Young Generation  It is a place where an object lived for a short period and it is divided into two spaces   Eden Space  When object created using new keyword memory allocated on this space  Survivor Space  S0 and S1   This is the pool which contains objects which have survived after minor java garbage collection from Eden space   Old Generation  This pool basically contains tenured and virtual  reserved  space and will be holding those objects which survived after garbage collection from the Young Generation   Tenured Space  This memory pool contains objects which survived after multiple garbage collection means an object which survived after garbage collection from Survivor space    Explanation Let s imagine our application has just started  So at this point all three of these spaces are empty  Eden  S0  S1   Whenever a new object is created it is placed in the Eden space  When the Eden space gets full then the garbage collection process  minor GC  will take place on the Eden space and any surviving objects are moved into S0  Our application then continues running add new objects are created in the Eden space the next time that the garbage collection process runs it looks at everything in the Eden space and in S0 and any objects that survive get moved into S1  PS  Based on the configuration that how much time object should survive in Survivor space  the object may also move back and forth to S0 and S1 and then reaching the threshold objects will be moved to old generation heap space

[java] How is the java memory pool divided?

Heap memory

Non-heap memory

Examples related to java

Examples related to memory

Examples related to pool