Multithreading & Concurrency Interview Questions

A thread is a lightweight unit of execution that allows concurrent execution of tasks within a process.

A process is an independent program in execution, while a thread is a smaller execution unit within a process that shares resources.

A thread can be created by extending the Thread class or implementing the Runnable interface.

Thread is a class, while Runnable is an interface. Implementing Runnable allows a class to extend another class.

A thread moves through New, Runnable, Running, Blocked/Waiting, and Terminated states during execution.

Synchronization controls access to shared resources, ensuring that only one thread accesses critical code at a time.

Synchronization prevents data inconsistency and race conditions when multiple threads access shared resources.

A deadlock occurs when two or more threads wait indefinitely for resources held by each other.

Deadlocks can be avoided through lock ordering, lock timeouts, minimizing nested locks, and using concurrent utilities.

A race condition occurs when multiple threads modify shared data simultaneously, producing unpredictable results.

sleep() pauses a thread for a specified time without releasing locks, while wait() releases the lock and waits for notification.

notify() wakes one waiting thread, whereas notifyAll() wakes all waiting threads.

volatile ensures that variable updates are immediately visible to all threads and prevents caching inconsistencies.

A thread pool is a collection of reusable worker threads that improves performance by reducing thread creation overhead.

The Executor Framework provides a high-level API for managing and executing asynchronous tasks using thread pools.

Name concrete APIs (collections, concurrency, streams, annotations) tied to Multithreading & Concurrency. Interviewers want syntax-level clarity plus when you would reach for each feature in production.

Prefer specific checked/unchecked exceptions, wrap lower-level failures with context, and avoid empty catch blocks. For Multithreading & Concurrency, decide what is recoverable vs fatal to the request thread.

JUnit 5 with Arrange-Act-Assert, Mockito for collaborators, and parameterized tests for edge cases. Keep Multithreading & Concurrency logic pure where possible so tests stay fast.

Incorrect equals/hashCode break HashMap/HashSet behavior. If Multithreading & Concurrency stores objects in collections, explain the contract and mutability pitfalls.

Retain only needed references, prefer streaming for large datasets, and avoid accidental caches. Relate leaks or GC pressure to a concrete Multithreading & Concurrency scenario.