Java Developer Interview Questions (JVM & Spring Framework)

What Java Developer Interviews Test

Java developer interviews test ecosystem knowledge through java multithreading interview questions requiring thread synchronization and concurrency patterns, JVM interview questions testing memory management and garbage collection understanding, and Spring Boot interview scenarios demonstrating dependency injection and auto-configuration. Companies probe how you handle race conditions preventing data corruption, optimize JVM performance tuning heap settings, and build RESTful services using Spring framework leveraging annotations and conventions. For comprehensive technical interview preparation, visit our complete IT interview guide.

These java developer interview questions cover thread lifecycle understanding states from NEW to TERMINATED, memory areas including heap and stack allocation, Spring Boot starter dependencies simplifying configuration, and Java concurrency questions using ExecutorService and concurrent collections. Modern Java development emphasizes functional programming with lambdas and streams introduced in Java 8, reactive programming using Spring WebFlux for non-blocking I/O, and microservices architecture decomposing applications into independently deployable services.

Multithreading & Concurrency

Q: Explain the difference between Thread and Runnable in Java.

Thread is a class you extend to create threads: class MyThread extends Thread { public void run() {...} }. Runnable is an interface you implement: class MyTask implements Runnable { public void run() {...} }, then pass to Thread constructor: new Thread(new MyTask()).start(). Runnable is preferred because Java doesn’t support multiple inheritance, allowing your class to extend another class while still creating threads. Runnable also promotes better design separating task logic from thread management. Modern Java favors ExecutorService over direct Thread creation managing thread pools efficiently.

Q: What is synchronization and why is it needed?

Synchronization prevents race conditions when multiple threads access shared data concurrently. Without synchronization, thread interleaving can cause data corruption. Example: two threads incrementing counter simultaneously may both read 5, increment to 6, resulting in 6 instead of 7. The synchronized keyword ensures only one thread executes critical section at a time. Synchronized methods lock on object instance (this), synchronized blocks can lock on any object. Acquiring lock causes other threads to wait preventing concurrent modification. Over-synchronization causes performance bottlenecks so minimize synchronized scope to critical sections only.

Q: Describe the thread lifecycle in Java.

Threads progress through states: NEW (created but not started), RUNNABLE (executing or ready to execute), BLOCKED (waiting for monitor lock), WAITING (waiting indefinitely for another thread), TIMED_WAITING (waiting for specified time), TERMINATED (completed execution). Call start() moving thread from NEW to RUNNABLE. Thread scheduler decides when RUNNABLE threads actually execute. Threads enter BLOCKED when trying to acquire lock held by another thread. wait() moves to WAITING, notify() returns to RUNNABLE. sleep() or wait(timeout) causes TIMED_WAITING. Thread reaches TERMINATED after run() completes or throws uncaught exception.

Q: What’s the difference between wait() and sleep()?

wait() is called on objects inside synchronized blocks, releasing the lock allowing other threads to acquire it. Thread waits until notify() or notifyAll() called on same object. sleep() is called on Thread class, pausing execution for specified milliseconds without releasing locks. wait() for inter-thread communication and coordination. sleep() for timed delays. wait() throws InterruptedException and must be inside synchronized context. sleep() also throws InterruptedException but doesn’t require synchronization. Example: Producer-Consumer uses wait()/notify(), rate limiting uses sleep().

💡 Pro tip: Java multithreading interviews often include follow-up questions. When explaining synchronized, be ready to discuss volatile keyword, ReentrantLock alternatives, or concurrent collections like ConcurrentHashMap demonstrating deeper knowledge beyond basics.

JVM Internals & Memory Management

Spring Boot & Framework

What is dependency injection and how does Spring implement it?

Explain Spring Boot auto-configuration.

How do you create RESTful web services in Spring Boot?

Advanced Concurrency & Collections

Q: What is ExecutorService and why use it over creating threads directly?

ExecutorService manages thread pool executing tasks asynchronously without creating new threads for each task. Create using Executors.newFixedThreadPool(5) reusing 5 threads, or newCachedThreadPool() creating threads as needed. Submit tasks: executorService.submit(() -> doWork()). Benefits include thread reuse reducing overhead, controlled concurrency limiting threads preventing resource exhaustion, and automatic thread lifecycle management. Provides Future for task results and cancellation. Always shut down: executorService.shutdown() or shutdownNow() preventing memory leaks. Prefer ExecutorService over raw threads for production code.

Q: Explain ConcurrentHashMap and how it differs from synchronized HashMap.

ConcurrentHashMap is thread-safe without synchronizing entire map, achieving better concurrency. It uses segmentation (Java 7) or CAS operations (Java 8+) allowing multiple threads to read/write different segments simultaneously. Synchronized HashMap locks entire map for every operation causing bottlenecks with high contention. ConcurrentHashMap provides atomic operations: putIfAbsent(), computeIfAbsent(), merge(). Iterators are weakly consistent reflecting some but not necessarily all concurrent modifications. Don’t use null keys or values unlike HashMap. For thread-safe collections, prefer concurrent versions: ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue over synchronized wrappers.

Q: What is deadlock and how do you prevent it?

Deadlock occurs when two or more threads wait indefinitely for locks held by each other. Example: Thread A holds Lock 1 waiting for Lock 2, Thread B holds Lock 2 waiting for Lock 1. Prevention strategies: Always acquire locks in same order across threads preventing circular wait. Use timeout with tryLock(timeout) abandoning if lock unavailable. Avoid nested locks when possible. Use higher-level concurrency utilities like ReentrantLock with try-finally for guaranteed unlock. Detect deadlocks using thread dumps (jstack) showing threads in BLOCKED state with lock dependencies. Design lock-free algorithms using atomic variables where appropriate.

Q: What is volatile keyword and when should you use it?

volatile ensures visibility of variable changes across threads. Without volatile, threads may cache variable values not seeing updates from other threads. volatile guarantees: Read always gets latest value from main memory, write immediately flushed to main memory. Use for flags: private volatile boolean running = true; ensuring other threads see updates. volatile provides visibility not atomicity; count++ is not atomic even with volatile. For atomic operations use AtomicInteger, AtomicLong. volatile is lighter than synchronized avoiding locking overhead but offers fewer guarantees. Consider for simple flags or state variables accessed by multiple threads.

⚠️ Common mistake: Thinking synchronized and volatile are interchangeable. synchronized provides both visibility and atomicity, locking critical sections. volatile only provides visibility without atomicity or mutual exclusion. Choose based on requirements: complex operations need synchronized, simple flags use volatile.

Java Ecosystem Practice

❓ FAQ

Final Thoughts

Mastering java developer interview questions requires combining theoretical knowledge with practical coding ability demonstrated through working examples. The best preparation includes practicing multithreading concepts with actual code creating threads, implementing synchronization, and handling race conditions rather than just reading about them. Understanding JVM fundamentals helps debugging production issues and optimizing application performance beyond passing interviews. Focus on explaining concepts clearly using real-world analogies since interviewers value communication skills alongside technical knowledge.

Companies value Java developers who understand the ecosystem beyond syntax: why Spring Boot simplifies configuration through convention over configuration, when to use concurrent collections versus synchronized wrappers, and how garbage collection impacts application behavior. Your preparation should include building small projects demonstrating Spring Boot REST services, practicing multithreading scenarios with ExecutorService, and experimenting with JVM flags observing their effects. Demonstrate both breadth across Java platform and depth in areas matching role requirements whether backend services, enterprise applications, or distributed systems development.