Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Java · Question Set
Java Memory Model, GC & Performance Tuning interview questions for placements and exams.
Questions
14
Included in this set
Subject
Java
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Java.
The JMM specifies when a thread’s write becomes visible to other threads and which re-orderings are allowed. It’s about visibility and happens-before guarantees, not physical layouts or GC details.
Weak references allow GC to reclaim entries aggressively—good for caches with no hard retention. Soft references are less aggressively reclaimed (historically for caches, though guidance now favors explicit policies). Phantom references are for post-mortem cleanup with ReferenceQueue; you cannot get the referent.
Finalizers run at GC’s discretion and can cause leaks or latency spikes. Use explicit close patterns or Cleaner for safety and determinism.
volatile publishes the latest value to all threads and prevents certain re-orderings. It does not make compound updates atomic; use locks or atomics for that.
If an object never escapes a method or thread, the JIT can allocate it on the stack (scalar replacement) and remove unnecessary synchronization, reducing GC pressure and contention.
Generational hypothesis: new objects tend to be short-lived. Minor collections reclaim them quickly, while the old generation is collected less often.
Both aim for sub-millisecond pauses by doing most GC work concurrently and using barriers to keep mutators running while objects move.
One: Measure first—enable GC logs and capture p99 latency and allocation rates. Two: Fix allocation hot spots—reduce temporary objects, reuse buffers, enable pooling only if profiling proves it. Three: Right-size the heap and young generation to match live-set and allocation rate. Four: Set realistic pause goals (e.g., G1 MaxGCPauseMillis) and re-measure. Only then consider switching collectors (e.g., to ZGC) if goals still aren’t met.
High allocation rates trigger more frequent young GCs and fill survivor/old regions faster, increasing pauses and promotion failures. Fewer temporary objects mean fewer barriers and less pressure on remembered sets. Lower churn gives the GC time to work concurrently, reducing pause frequency and tail latencies.
Metaspace holds class metadata (replacing PermGen). A common growth cause is classloader leaks—dynamically loading classes without unloading their defining classloader, often seen in hot-reloaded apps or container redeploys. Each leaked classloader pins its classes and metadata, expanding Metaspace.
Releasing a monitor happens-before the subsequent acquire of that monitor by another thread. This ensures visibility of changes made inside the critical section.
G1 uses regions and mixed collections to meet pause goals. CMS is concurrent but largely non-compacting and can suffer fragmentation.
At safepoints the JVM halts mutator threads. If a thread can’t poll (e.g., busy native call or hot loop with eliminated polls), the VM waits, inflating pause time.
It identifies duplicate string contents and shares a single backing array, cutting memory footprint when many equal strings exist. It’s orthogonal to String.intern().
For complete preparation, combine this set with full subject-wise practice for Java. You can also explore other subjects and sets from the links below.