See how class files become running code across the JVM, heap, stack, metaspace, and native memory.
Advanced Java · runtime
Use the strong answer as your reference, explain it aloud in your own words, then choose how soon you want to review it again.
Interview prompt
Strong answer
A running Java process includes JVM-managed memory and native resources. Objects generally live in the heap, each thread has its own stack, class metadata lives in metaspace, and native allocations may sit outside the heap. The JVM specification describes behavior, while a particular JVM implementation decides many memory details.
Key points
Interviewer looks for
Separate specification guarantees from HotSpot implementation details and distinguish memory exhaustion from a logical retention leak.
Java example
1final class UserCache {
2 private final Map<String, User> values = new ConcurrentHashMap<>();
3 void put(String id, User user) { values.put(id, user); }
4 // Production code also needs an eviction or lifecycle policy.
5}Topic interview questions
These questions are tied to this lesson. Read each question aloud, then compare your explanation with the strong answer.
Strong answer
The shared heap stores ordinary objects, each thread's stack stores call frames and local execution state, and metaspace stores class metadata in common HotSpot implementations. Native memory also exists outside these areas.
Strong answer
StackOverflowError commonly means a thread exhausted its stack through deep or infinite calls. OutOfMemoryError means the JVM or a native allocation could not obtain required memory, which may involve the heap, metaspace, or another region.
Strong answer
It is unnecessary retention of objects that remain reachable from GC roots, so the collector cannot reclaim them. Common causes include unbounded caches, static collections, listeners, and forgotten ThreadLocal values.
Strong answer
GC roots are starting points the collector treats as live, such as active thread stacks, static fields, JNI references, and monitor references. Objects reachable from roots are considered live.
Strong answer
The source-level symptom may be far from the cause: high allocation, retained objects, native buffers, thread stacks, or class metadata can all look like memory pressure. Heap dumps, native memory tracking, and runtime metrics separate those cases.
How well do you know this?
Your review choice is saved locally and synced to your learner profile when signed in.