Language and framework depth for JVM roles, covering the internals that separate framework users from engineers who understand what runs underneath.
41 published across 10 topics.
Object semantics, equals and hashCode contracts, generics, exceptions, and immutability.
Generic type arguments exist only for the compiler; the bytecode keeps a raw type plus a signature string, which is why there is no T.class and no new T[]. Wildcards then follow producer-extends, consumer-super: read through ? extends, write through ? super.
Equal objects must produce equal hash codes. Break that and a HashMap sends lookups to a bucket the entry was never placed in, so the map holds a value you can no longer retrieve and a set silently admits duplicates. The same failure appears later if a key is mutated after insertion.
Boxing produces objects, so == compares references. The specification requires small values to come from a cache, which is why comparisons on small numbers appear to work and fail above the cached range. The other costs are a NullPointerException on unboxing and overload resolution preferring the primitive method.
Implementation internals, resizing behaviour, ordering guarantees, and choosing the right collection.
A declaration shows whether you chose a structure for its access pattern: Stack or LinkedList where ArrayDeque belongs, a List used for membership tests, a concrete type on a signature. Programming to interfaces helps only if the code stays efficient for every implementation it accepts.
The sort detected that your comparator contradicted itself partway through a merge. The usual causes are a subtraction that overflows, an ordering that is not transitive, and a sort key that changes while the sort is running. Use this collections answer to show the decision, trade-off, and evidence rather than a memorised definition. It also connects sorting to the point an interviewer is testing.
HashMap stores entries in an array of buckets indexed by a hash of the key; collisions chain into a linked list that converts to a red-black tree past a threshold, and exceeding the load factor triggers a resize that reallocates and redistributes every entry. It also connects collections to the point an interviewer is testing.
Structural modification through the collection during a for-each invalidates the iterator, which detects it by comparing a modification counter and throws ConcurrentModificationException. Remove through the iterator, or use removeIf, or pick a collection whose iterator is weakly consistent instead.
The memory model, executors, locks, atomics, virtual threads, and diagnosing races and deadlocks.
A thread-safe connection pool pairs a Semaphore of N permits, which bounds how many connections exist and gives acquire its timeout, with a queue of idle connections. Acquire returns a lease that releases exactly once from a finally block, and a broken connection is discarded without losing its permit.
Thread safety composes per operation, not across operations. A get followed by a put is two atomic steps with a legal interleaving between them. You close the window by making the whole compound action one operation, such as compute or merge, or by holding a single lock across both steps.
Virtual threads make blocking cheap by unmounting from their carrier OS thread whenever they block, so thread-per-request scales to hundreds of thousands of concurrent tasks. Finalised in JDK 21, they do nothing for CPU-bound work, and pooling them defeats their purpose.
It guarantees visibility and ordering: a volatile write happens-before every later read of that field, so everything the writer did beforehand becomes visible to the reader. It guarantees nothing about atomicity, so an increment is still a race and a volatile reference says nothing about the object it points to.
Class loading, memory regions, garbage collectors, and reading a heap dump or GC log.
Most likely into reaching the safepoint. Every application thread has to arrive at a poll point before the operation can begin, and one late thread stalls all of them, so the pause is time-to-safepoint plus the actual work. Safepoint logging separates the two.
Loaders delegate to their parent before searching themselves, so the JDK always wins a name clash. ClassNotFoundException means a loader was asked for bytes it could not find; NoClassDefFoundError means the JVM needed a class that was there at compile time, or one whose static initialiser had already failed.
Test the candidate's ability to design custom memory management strategies, focusing on memory fragmentation, deterministic allocation times, and safety-critical constraints. Use this hardware answer to show the decision, trade-off, and evidence rather than a memorised definition.
Read the message text first, because it names which region ran out. Then use the GC log to see whether the live set after each full collection is trending upward, which means a leak, or flat and close to the ceiling, which means the heap is simply too small. A heap dump tells you what is retaining the memory.
Analyse JVM tuning strategies to prevent Stop-The-World (STW) pauses and ensure predictable microsecond response times for game server logic. It also connects garbage collection to the point an interviewer is testing.
Lazy evaluation, collectors, parallel streams, and the readability and performance traps.
It assumed unique keys and non-null values. Collectors.toMap throws IllegalStateException on a duplicate key and NullPointerException on a null value, so supply a merge function that encodes a real rule, use groupingBy when duplicates are legitimate, or collect into a HashMap directly if nulls must survive.
No. Since JDK 9, count() may skip the pipeline entirely when the size is known from the source and no stage adds or removes elements, so peek never runs. Stream laziness means stages run only when the terminal operation needs them, which makes side effects in peek or map unreliable rather than merely bad style.
Laziness means intermediate operations only describe a pipeline, so nothing traverses the source until a terminal operation pulls, and short-circuiting operations can stop early. Parallel helps when the source splits evenly, the work per element is CPU-bound and substantial. Use this streams answer to show the decision, trade-off, and evidence rather than a memorised definition.
A collector is a supplier of a mutable container, an accumulator that folds one element into it, a combiner that merges two containers, and a finisher. The combiner runs only in parallel, which is why an untested combiner is the usual defect, and the characteristics tell the pipeline what it may skip or reorder.
Records, sealed types, pattern matching, and the language changes that reshape idiomatic code.
Java records have shallow immutability: fields are final, but a List or array component can still change through its reference unless the compact constructor copies it. A record cannot be a JPA entity, because the class and fields are final, it lacks a no-arg constructor, and providers subclass and populate entities.
Together they let you write closed data hierarchies the compiler can check. A record declares that a type is its components, a sealed interface enumerates the permitted variants, and an exhaustive switch over record patterns turns adding a variant into a compile error at every place that handles them.
Strong encapsulation of JDK internals became the default in JDK 16 and JDK 17 removed the option to relax it wholesale, so deep reflection into a package nobody opened now throws instead of warning. The fix is a targeted --add-opens for one module and package, or a library version that no longer needs one.
Dependency injection, bean lifecycle, scopes, proxies, and why an AOP annotation silently does nothing.
REQUIRES_NEW suspends the caller's transaction and commits the audit on a second connection, so the row survives a later rollback if the call goes through the Spring proxy. It hangs when the audit touches rows the suspended transaction has locked, or when every thread holds one pooled connection and waits for another.
NoUniqueBeanDefinitionException means one injection point matches two beans by type. Fix it where the decision belongs: a qualifier at the consumer when callers need different beans, a List or Map when all are used, a conditional bean when only one should exist. A primary bean is the quick fix that ages worst.
Spring Boot has prohibited circular references by default since 2.6. Setting spring.main.allow-circular-references=true restores the old behaviour, defensible only as a dated stopgap. The fix is to break the cycle, usually by extracting what both services need, and to use constructor injection so new cycles fail fast.
Prototype scope means a new instance per request to the container, and a singleton asks once, at construction. Inject an ObjectProvider and call getObject() each time you need a fresh instance. A scoped proxy also works, but on a prototype it creates a new target on every method call, which is rarely what you meant.
Spring applies @Transactional through a proxy that wraps the bean. Calling the annotated method from another method of the same class goes through `this`, not the proxy, so the advice never runs and no transaction is started. The same silence affects @Cacheable, @Async and @Retryable. It also connects dependency injection to the point an interviewer is testing.
The inner method joined the caller's transaction, so its rollback rule marked the one physical transaction rollback-only. Catching the exception hides it from your code but not from the transaction manager, which then refuses to commit. Use REQUIRES_NEW when the inner work must be able to fail alone.
Auto-configuration mechanics, configuration precedence, actuator, and production-readiness concerns.
First stop the kills: add a Kubernetes startup probe with a budget longer than the worst observed start, and point liveness and readiness at Actuator's separate health groups. Then measure where the 50 seconds goes before tuning, because lazy initialisation only moves the cost onto the first requests.
Ask the running application, not the files. Actuator's env endpoint queried for that property lists the property sources in precedence order with the value each holds, the first holder winning. Then trace it: an environment variable matched by relaxed binding, a profile file, a command-line argument or a JVM system property.
Expose health to the platform, metrics to the scraper, and nothing else over HTTP without authentication, ideally on a separate management port. The quiet leak is heapdump: masking protects the env and configprops responses, but a heap dump holds every secret, token and customer record in memory unmasked.
@Value injects one expression per field with no grouping, no relaxed name matching and no validation. @ConfigurationProperties binds a whole subtree onto a typed object, matches names loosely, handles lists and nested types, and combined with @Validated it fails the context refresh when the environment is wrong.
Spring Boot auto-configuration loads candidate classes from AutoConfiguration.imports, applies conditional annotations, and backs off when your own beans or properties already define the needed behavior.
Entity lifecycle, lazy loading and N+1, transaction propagation, and generated-SQL debugging.
The repository call fetches parents in one query; the extra queries come later, when something touches a lazy association - usually the JSON serialiser, with open-session-in-view keeping the context alive so it succeeds silently. Diagnose by counting statements per request, then fix with a join fetch or entity graph, batch fetching, or a DTO projection.
Hibernate dirty checking tracks a managed JPA entity through the persistence context. At flush the provider compares the entity against its loaded snapshot and writes an UPDATE for whatever differs, so mutating a managed object inside a transaction is itself the instruction to persist. Use this spring data jpa answer to show the decision, trade-off, and evidence rather than a memorised definition.
You get N+1 when one query loads N rows and something later dereferences a lazy association on each of them, firing a select apiece. Fix it per call site with join fetch, an entity graph, or batch fetching - not by changing mappings to EAGER.
Spring Data JPA saveAll batching needs a Hibernate batch size, statements for the same table kept adjacent, and an identifier strategy that does not force a round trip per row. IDENTITY generation silently prevents insert batching, because Hibernate has to execute each insert to learn the key.
Unit versus integration boundaries, mocking strategy, Testcontainers, and suite design.
Mostly into starting Spring application contexts. Context caching reuses one context per distinct test configuration, so each unique mock bean, property set, profile or @DirtiesContext forces a fresh start. Count contexts from the cache statistics log, converge the configurations, and move narrow tests to slices.
Make time and scheduling injectable. Take a java.time.Clock as a dependency so a test can fix it, and replace a fixed sleep with a bounded poll on the observable outcome, so a fast machine does not wait and a slow one does not fail.
Draw the line by what the test is allowed to touch - a unit test stays in-process, an integration test crosses a real boundary. Mock collaborators, never the component under test. Use Testcontainers for real dependencies and keep the suite fast by reusing the Spring context and the containers.