Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
24 results across 1 active filter
Page 1 of 1
Defines managed memory leaks as unwanted reachability and connects caches, listeners, class loaders, ThreadLocal values, and queues to retaining paths.
Explains optimistic atomic updates, retries, contention, immutable state replacement, and the boundary of single-variable safety.
Explains GC roots, reachability, generational behavior, pauses, and why setting a reference to null is not a general cleanup strategy.
Explains circular lock waits, consistent ordering, reduced lock scope, timed acquisition, and thread-dump confirmation.
Explains cheap JVM-scheduled threads, blocking-I/O throughput, carrier pinning, ThreadLocal cost, and unchanged downstream limits.
Designs executor ownership, pool size, queue capacity, rejection, shutdown, task context, and observability around workload behavior.
Frames collector and heap decisions around service goals, workload evidence, pause distributions, live set, and deployment limits.
Uses multiple thread dumps, CPU correlation, lock ownership, executor context, and request evidence to distinguish deadlock, contention, blocking, and hot loops.
Treats interruption as a cooperative request, preserves interrupt status, defines cleanup, and separates cancellation signals from guaranteed task termination.
Triages heap, Metaspace, native, direct-buffer, thread, and container exhaustion using preserved evidence before changing limits.
Diagnoses queued work, blocked workers, nested submissions, common-pool contention, downstream waits, and misleading CPU symptoms.
Defines races through timing-dependent shared-state operations and evaluates confinement, immutability, synchronization, and atomic tools.
Explains visibility and ordering through synchronization actions instead of misleading main-memory and thread-cache folklore.
Explains monitor mutual exclusion, visibility, reentrancy, lock identity, scope, and contention.
Explains making a fully constructed object visible through valid happens-before edges and final-field semantics.
Separates rapidly created short-lived objects from object graphs that remain reachable and chooses evidence and fixes accordingly.
Separates managing overlapping tasks from executing work simultaneously and connects both to Java backend design.
Contrasts blocking result retrieval with composable completion stages, explicit executors, failure handling, and limited cancellation guarantees.
Explains heap, per-thread stacks, Metaspace, code cache, and native memory through the failures and evidence they produce.
Chooses visibility, mutual exclusion, or atomic read-modify-write based on the invariant instead of treating the tools as interchangeable.
Explains per-thread state, pooled-thread leakage, context cleanup, hidden dependencies, and virtual-thread scaling concerns.
Chooses concurrent collections by required atomic operations and iteration semantics rather than treating them as synchronized replacements.
Explains monitor wait sets and guarded loops while preferring queues, latches, semaphores, futures, and conditions for standard coordination.
Chooses an explicit lock only when timed, interruptible, conditional, or advanced acquisition behavior justifies manual lifecycle.