Skip to content

Tracks Drills Topics Technologies Tech stacks Skill areas

Tracks Drills Topics

Loading

Aporeon

Technical interview practice, from one developer to another.

About Support Privacy Terms Refund policy

Java & Spring Backend

JVM Memory & Concurrency

Memory and garbage collection, thread safety, executors, futures, locks, concurrent collections, virtual threads, and runtime diagnosis.

24 drillsPractice one at a timeOrdered pathConcept questionDebugging scenarioComparison questionArchitecture scenario

Recommended start

JVM memory areas

Explains heap, per-thread stacks, Metaspace, code cache, and native memory through the failures and evidence they produce.

Medium~7 minStep 1 of 24

Practice this drill Choose another

Search

24 of 24 shown

1JVM memory areasRecommended startExplains heap, per-thread stacks, Metaspace, code cache, and native memory through the failures and evidence they produce.Concept questionMedium~7 minJavaPractice 2GC and reachabilityExplains GC roots, reachability, generational behavior, pauses, and why setting a reference to null is not a general cleanup strategy.

Practice order

24 drillsOne at a time

1JVM memory areasUp next / Medium / ~7 min
2GC and reachabilityMedium / ~7 min
3Java memory leaksMedium / ~7 min
4

Concept questionMedium~7 minJava

Practice

3Java memory leaksDefines managed memory leaks as unwanted reachability and connects caches, listeners, class loaders, ThreadLocal values, and queues to retaining paths.Concept questionMedium~7 minJavaPractice

4Diagnose OutOfMemoryErrorTriages heap, Metaspace, native, direct-buffer, thread, and container exhaustion using preserved evidence before changing limits.Debugging scenarioHard~10 minJavaPractice

5Allocation vs retentionSeparates rapidly created short-lived objects from object graphs that remain reachable and chooses evidence and fixes accordingly.Comparison questionMedium~7 minJavaPractice

6GC tuning trade-offsFrames collector and heap decisions around service goals, workload evidence, pause distributions, live set, and deployment limits.Architecture scenarioHard~10 minJavaPractice

7ThreadLocal lifecycleExplains per-thread state, pooled-thread leakage, context cleanup, hidden dependencies, and virtual-thread scaling concerns.Concept questionHard~10 minJavaPractice

8Concurrency vs parallelismSeparates managing overlapping tasks from executing work simultaneously and connects both to Java backend design.Comparison questionEasy~5 minJavaPractice

9Race conditionsDefines races through timing-dependent shared-state operations and evaluates confinement, immutability, synchronization, and atomic tools.Concept questionMedium~7 minJavaPractice

10Happens-beforeExplains visibility and ordering through synchronization actions instead of misleading main-memory and thread-cache folklore.Concept questionHard~10 minJavaPractice

11synchronized guaranteesExplains monitor mutual exclusion, visibility, reentrancy, lock identity, scope, and contention.Concept questionMedium~7 minJavaPractice

12volatile vs locks vs atomicsChooses visibility, mutual exclusion, or atomic read-modify-write based on the invariant instead of treating the tools as interchangeable.Comparison questionHard~10 minJavaPractice

13Atomics and CASExplains optimistic atomic updates, retries, contention, immutable state replacement, and the boundary of single-variable safety.Concept questionHard~10 minJavaPractice

14ReentrantLock vs synchronizedChooses an explicit lock only when timed, interruptible, conditional, or advanced acquisition behavior justifies manual lifecycle.Comparison questionMedium~7 minJavaPractice

15Safe publicationExplains making a fully constructed object visible through valid happens-before edges and final-field semantics.Concept questionHard~10 minJavaPractice

16Java deadlocksExplains circular lock waits, consistent ordering, reduced lock scope, timed acquisition, and thread-dump confirmation.Debugging scenarioHard~10 minJavaPractice

17Interruption and cancellationTreats interruption as a cooperative request, preserves interrupt status, defines cleanup, and separates cancellation signals from guaranteed task termination.Concept questionHard~10 minJavaPractice

18wait/notify vs higher-level toolsExplains monitor wait sets and guarded loops while preferring queues, latches, semaphores, futures, and conditions for standard coordination.Comparison questionHard~10 minJavaPractice

19Concurrent collectionsChooses concurrent collections by required atomic operations and iteration semantics rather than treating them as synchronized replacements.Architecture scenarioHard~10 minJavaPractice

20ExecutorService designDesigns executor ownership, pool size, queue capacity, rejection, shutdown, task context, and observability around workload behavior.Architecture scenarioHard~10 minJavaPractice

21Thread-pool starvationDiagnoses queued work, blocked workers, nested submissions, common-pool contention, downstream waits, and misleading CPU symptoms.Debugging scenarioHard~10 minJavaPractice

22Future vs CompletableFutureContrasts blocking result retrieval with composable completion stages, explicit executors, failure handling, and limited cancellation guarantees.Comparison questionMedium~7 minJavaPractice

23Virtual vs platform threadsExplains cheap JVM-scheduled threads, blocking-I/O throughput, carrier pinning, ThreadLocal cost, and unchanged downstream limits.Comparison questionHard~10 minJavaPractice

24Thread-dump diagnosisUses multiple thread dumps, CPU correlation, lock ownership, executor context, and request evidence to distinguish deadlock, contention, blocking, and hot loops.Debugging scenarioHard~10 minJavaPractice

Diagnose OutOfMemoryError

Hard / ~10 min

5Allocation vs retentionMedium / ~7 min

6GC tuning trade-offsHard / ~10 min

7ThreadLocal lifecycleHard / ~10 min

8Concurrency vs parallelismEasy / ~5 min

+16 more drills in this section

JVM Memory & Concurrency - Java & Spring Backend | Aporeon