Understanding Java Reference Types and JVM Memory Management

1. Four Types of Java References

Strong Reference : The most common reference. When an object is created with new and a variable points to it, the object has a strong reference and will never be reclaimed by the garbage collector; if memory runs out the JVM throws OutOfMemoryError instead of discarding it.

Soft Reference : The object is reclaimed only when the JVM detects memory shortage. While memory is sufficient the object remains reachable, making soft references useful for memory‑sensitive caches.

Weak Reference : Objects with only weak references are reclaimed on every GC cycle regardless of memory pressure, though the low‑priority GC thread may not detect them immediately.

Phantom Reference : Does not affect an object's lifetime; the object is reclaimed like an unreferenced one. Phantom references are mainly used to track when an object has been collected.

2. JVM Memory Areas

The JVM divides runtime memory into several regions, each with specific management rules.

1. Program Counter (Thread‑Local)

Each thread has its own PC, created with the thread.

Points to the address of the next instruction.

When executing native methods the value is undefined.

2. Java Virtual Machine Stack (Thread‑Local)

Each method invocation creates a stack frame that stores the local variable array, operand stack, dynamic linking information, and return address. The local variable array holds primitive values and object references known at compile time.

The JVM defines two error conditions for this area:

StackOverflowError – when a thread requests a stack depth beyond the allowed limit (e.g., infinite recursion).

OutOfMemoryError – when the stack cannot be expanded because the JVM cannot obtain more native memory.

3. Native Method Stack

Serves native methods similarly to the JVM stack. In HotSpot the native stack is merged with the JVM stack, but it can still throw StackOverflowError and OutOfMemoryError.

4. Heap (Shared)

The largest JVM memory region, shared by all threads, stores virtually all object instances. It is the primary GC‑managed area and is logically divided into the Young Generation and Old Generation. The heap may be physically non‑contiguous but must appear contiguous to the JVM.

5. Method Area (Shared)

Stores class metadata, constant pool, static variables, and JIT‑compiled code. In HotSpot this area is called the Permanent Generation (PermGen); the runtime constant pool is a key component.

3. Object States in Memory

Reachable (Accessible) : An object referenced directly or indirectly from GC roots.

Recoverable : An object no longer referenced; before reclamation its finalize() method may run, and if the method resurrects the object it becomes reachable again.

Unreachable : After finalize() runs and the object is still not referenced, it becomes truly unreachable and will be reclaimed.

4. Common Algorithms for Determining Object Death

Reference Counting : Each object maintains a counter incremented on new references and decremented when references disappear; objects with a count of zero are eligible for collection. Java does not use this algorithm because it cannot handle cyclic references.

Root Search (Mark‑Sweep) : The JVM treats a set of GC roots; any object not reachable from these roots is considered dead and can be reclaimed.

5. Garbage‑Collection Algorithms

Mark‑Sweep : Marks all reachable objects from the roots, then sweeps away the unmarked ones.

Copying (Young Generation) : Divides the memory into two halves; live objects are copied to the unused half during collection, and the other half is cleared.

Mark‑Compact (Old Generation) : After marking reachable objects, compacts them to one end of the heap to eliminate fragmentation.

Generational Collection : Uses different strategies based on object survival rates—copying for the young generation where most objects die quickly, and mark‑compact or mark‑sweep for the old generation where objects survive longer.

6. Garbage Collectors

Serial Collector : Single‑threaded; pauses all application threads (Stop‑The‑World) during collection.

ParNew Collector : Multithreaded version of Serial, the default young‑generation collector in Server mode and works with the CMS collector.

ParNew Scanvenge Collector : Similar to ParNew but tuned for higher throughput, trading longer pause times for better overall throughput.

G1 Collector : Modern collector introduced in JDK 7, aims to provide predictable pause times while handling large heaps.

CMS Collector : Concurrent Mark‑Sweep, targets minimal pause times, suitable for latency‑sensitive server applications.

7. Heap Segmentation

The heap is split into Young Generation and Old Generation. The Young Generation consists of Eden, From‑Survivor, and To‑Survivor spaces and is collected using the copying algorithm (minor GC). The Old Generation is collected with mark‑sweep/mark‑compact (full GC). Prior to Java 8, a Permanent Generation existed; it has been replaced by Metaspace, which resides outside the heap.

8. Class Loading Mechanism

The JVM loads class data from .class files, verifies, parses, and initializes it, turning the raw bytes into runtime Java types that can be used directly by the virtual machine.

9. Common Interview Questions

Subclass Initialization : A subclass is initialized only when its static members are actively accessed; otherwise only the superclass is initialized.

Static Final Constants : Accessing a static final constant does not trigger class initialization because the value is inlined at compile time.

These points are frequently tested in Java interview quizzes.