10.2. JVM Memory Model

Heap Memory:

• Stores all Java objects and class instances.
• Divided into Young Generation and Old Generation.

Non-Heap Memory:

• Stores metadata, loaded classes, method area, and JIT-compiled code.

The JVM divides memory into two main categories: Heap Memory and Non-Heap Memory.

1. Heap Memory is where all Java objects and class instances are stored. This is crucial for the JVM because every time a new object is created in Java, it is allocated memory in the heap.

   • It is further divided into two segments:
     • Young Generation: This space is for short-lived objects. When you create a new object, it usually starts here.
     • Old Generation: Once an object survives enough garbage collections from the Young Generation, it is moved here for long-term storage.

2. Non-Heap Memory is where data that is not collected by the garbage collector is stored. This includes necessary metadata about classes loaded by the JVM, the method area where class structures are held, and JIT-compiled code that is native machine code produced by the compiler. Thus, it supports the execution of Java applications by maintaining essential information and optimizing performance.

Think of Heap Memory as a general-purpose storage room in a school where students' backpacks (Java objects) are kept. The Young Generation is like the area for new backpacks that will only be used for a short time, while the Old Generation is for those backpacks that have been around for longer, indicating they’re used frequently. On the other hand, Non-Heap Memory can be compared to a library's archives (metadata and compiled code) where important records about each student (class data) and their studies (method area) are kept safe and organized for reference.

Young Generation:

• Includes Eden and Survivor spaces; short-lived objects are here.

Old Generation (Tenured):

• Long-lived objects promoted from Young Gen.

Metaspace (Java 8+):

• Replaces PermGen to store class metadata.

This section provides a deeper understanding of specific memory areas within the JVM's memory model:

1. Young Generation: This area is used for short-lived objects. It consists of:

   • Eden Space: Where new objects initially reside when created.
   • Survivor Spaces: There are usually two of these, where objects that survive garbage collection in Eden are moved. When an object is not needed anymore, it is removed from the Eden Space, but if it remains in Survivor space after a few cycles, it might be promoted to the Old Generation.

2. Old Generation (Tenured): Objects that survive multiple collections in the Young Generation are promoted to this space. These are expected to last longer, and garbage collection here occurs less frequently. Since the objects are long-lived, managing this space efficiently is crucial for overall application performance.

3. Metaspace (Java 8+): In versions of Java 8 and later, PermGen space was replaced with Metaspace. Unlike PermGen which had a fixed size, Metaspace dynamically resizes based on the amount of metadata required for classes loaded in the JVM. It is allocated in native memory rather than on the heap, providing improved flexibility and reducing out-of-memory errors related to metadata.

You can think of the Young Generation as a new section in a library where the latest publications (short-lived objects) are kept. Eden is like the new arrivals shelf, while Survivor spaces are like the returns section where books that didn't circulate much but are worth saving for a while are stored. The Old Generation functions like a reference section for older books that are still relevant but seldom checked out. Finally, Metaspace is like the library's index, which has the ever-evolving catalog of all books and materials but does not take up shelf space, allowing it to grow without a rigid limitation.

--