Java / Java Concurrency and Multi Threading in Java 17 and Java 21 Interview questions
1. What is a thread in Java?
A thread is the smallest independently schedulable unit of execution inside a process. Every thread has its own call stack, program counter, and local variables, but it shares the process's heap memory, open files, and static fields with every other...
2. What is multithreading in Java?
Multithreading is the ability of a Java program to run multiple threads concurrently within a single process, letting the JVM interleave or truly parallelize independent pieces of work across CPU cores. Instead of executing tasks one after another on a...
3. What are the different states of a thread in Java?
A Java thread moves through a well-defined set of states, represented by the Thread.State enum, over its lifetime. State Meaning NEW Thread object created but start() not yet called....
4. How do you create a thread in Java?
There are three common ways to create and run a thread in Java. The first is extending Thread and overriding run() ....
5. What is the Runnable interface used for?
Runnable is a functional interface with a single abstract method, void run() , that takes no arguments and returns no value. It represents a unit of work that can be executed by a thread without tying that logic to any...
6. What is a daemon thread in Java?
A daemon thread is a background thread that the JVM does not wait for when deciding whether to exit. Once every non-daemon (user) thread has finished, the JVM shuts down immediately, even if daemon threads are still running, terminating them...
7. What is thread priority in Java?
Thread priority is an integer hint, ranging from Thread.MIN_PRIORITY (1) to Thread.MAX_PRIORITY (10), with Thread.NORM_PRIORITY (5) as the default, that suggests to the thread scheduler how important a thread's execution is relative to others. You set it with thread.setPriority(int) and...
8. What is the purpose of the synchronized keyword?
The synchronized keyword provides mutual exclusion: it ensures that only one thread at a time can execute a block of code or method that is guarded by the same lock, called a monitor. You can apply it to an instance...
9. What is the purpose of the volatile keyword?
volatile guarantees visibility: whenever a thread writes to a volatile field, that write is immediately flushed to main memory, and any thread that subsequently reads the field is guaranteed to see the latest value rather than a stale, cached copy....
10. What are the types of locks available in java.util.concurrent.locks?
The java.util.concurrent.locks package offers explicit lock implementations that go beyond what the intrinsic synchronized keyword can do. Lock type Best used for ReentrantLock General-purpose mutual exclusion with tryLock, timeouts, interruptibility, and fairness options.
11. Define a race condition in multithreading?
A race condition occurs when two or more threads access shared mutable state concurrently, and the final outcome depends on the unpredictable timing or interleaving of their operations, rather than being deterministic. class Counter { int value = 0 ;...
12. What is the Executor framework in Java?
The Executor framework, in java.util.concurrent , separates task submission from the mechanics of how and when each task runs on a thread. Instead of manually creating and managing Thread objects, you submit Runnable or Callable tasks to an Executor or...
13. What is a virtual thread in Java 21?
A virtual thread is a lightweight thread implemented and scheduled entirely by the JVM rather than mapped one-to-one to an OS thread. It was delivered as a stable feature (JEP 444) in Java 21, the result of Project Loom....
14. What is a thread pool?
A thread pool is a managed collection of reusable worker threads that pull tasks from a shared queue and execute them, instead of creating a brand-new thread for every task and discarding it afterward. Reusing threads avoids the relatively high...
15. Describe the purpose of the java.util.concurrent package?
java.util.concurrent is Java's standard library for building concurrent applications without hand-writing low-level wait() / notify() logic and manual locking for every scenario. It bundles several categories of tools: the Executor framework for managing thread pools and asynchronous tasks; concu
16. How does the synchronized keyword achieve mutual exclusion internally?
Every Java object carries an intrinsic lock, or monitor. When a thread enters a synchronized method or block, the JVM emits a monitorenter bytecode instruction that attempts to acquire that object's monitor; a matching monitorexit releases it on normal exit...
17. Why should you prefer ReentrantLock over synchronized in some cases?
ReentrantLock offers capabilities the intrinsic synchronized keyword simply doesn't have. It supports tryLock() with an optional timeout, so a thread can back off instead of blocking forever; lockInterruptibly() , so a thread waiting for the lock can respond to interruption;...
18. What is the difference between wait() and sleep()?
wait() sleep() Defined on Object . Defined as a static method on Thread ....
19. What is the difference between notify() and notifyAll()?
Both methods are called on an object whose monitor the current thread holds, and both wake threads that are blocked in wait() on that same object. notify() wakes exactly one waiting thread, chosen arbitrarily by the JVM; there's no way...
20. How does ConcurrentHashMap achieve thread safety?
Modern ConcurrentHashMap (Java 8 onward) does not lock the entire map for every operation. Instead, it locks at the granularity of a single bin (bucket)....
21. What is the difference between ConcurrentHashMap and Hashtable?
ConcurrentHashMap Hashtable Locks per-bin; high concurrency for reads and writes. Synchronizes every method on a single lock for the whole map.
22. Why should you use CompletableFuture instead of Future?
A plain Future only lets you check whether a task is done ( isDone() ) or block until it finishes ( get() ). There's no way to attach a callback, react to completion asynchronously, or combine it with another Future...
23. How does the ForkJoinPool execute tasks?
ForkJoinPool is designed for divide-and-conquer workloads: a large task is recursively split into smaller subtasks until they're cheap enough to compute directly, then results are combined. You express this with RecursiveTask<V> (returns a value) or RecursiveAction (no return value)....
24. What is the difference between Runnable and Callable?
Runnable Callable<V> Method: void run() Method: V call() throws Exception Cannot return a result. Returns a value of type V....
25. How do you handle thread interruption in Java?
Interruption is a cooperative signal, not a forced stop. Calling thread.interrupt() sets an internal interrupt flag on that thread; it's up to the target thread's code to check for and respond to it....
26. What happens when a deadlock occurs in a multithreaded application?
A deadlock happens when two or more threads each hold a lock that another thread in the group needs, and each waits forever for the other to release it, forming a circular chain that never breaks on its own. flowchart...
27. When should you use CountDownLatch instead of CyclicBarrier?
CountDownLatch CyclicBarrier One-time use; count can only decrease and never resets. Reusable; automatically resets once the barrier trips.
28. How does compare-and-swap (CAS) work in atomic classes?
CAS is a single atomic CPU instruction (like cmpxchg on x86) that takes a memory location, an expected value, and a new value. It compares the current value at that location to the expected value; if they match, it atomically...
29. What is the difference between ExecutorService shutdown() and shutdownNow()?
shutdown() shutdownNow() Graceful: stops accepting new tasks but lets queued and running tasks finish. Aggressive: attempts to stop actively executing tasks and returns tasks that were never started.
30. How is the Java Memory Model relevant to concurrent programming?
The Java Memory Model (JMM), formalized in JSR-133, defines the rules for when a write to a shared variable by one thread is guaranteed to be visible to a read by another thread, and what reorderings of instructions the compiler...
31. How does ThreadLocal work internally?
Each Thread instance internally carries its own ThreadLocalMap , a specialized hash map. Calling threadLocal.set(value) or .get() from a given thread reads or writes an entry in that specific thread's map, keyed by the ThreadLocal instance itself....
32. What is the difference between CopyOnWriteArrayList and a synchronized ArrayList?
CopyOnWriteArrayList Collections.synchronizedList(new ArrayList<>()) Every mutation copies the entire underlying array. Every method call is synchronized on a single shared lock.
33. When would you choose a fixed thread pool over a cached thread pool?
A fixed thread pool ( Executors.newFixedThreadPool(n) ) keeps exactly n threads alive for its lifetime and queues excess tasks on an unbounded queue. A cached thread pool ( Executors.newCachedThreadPool() ) creates new threads as needed, reuses idle ones, and lets...
34. How does a BlockingQueue support the producer-consumer pattern?
A BlockingQueue adds blocking behavior on top of a normal queue: put() blocks the calling thread if the queue is full (for bounded queues), and take() blocks if the queue is empty, until an item becomes available. BlockingQueue<Task> queue =...
35. What happens when you call start() twice on the same thread?
Calling start() a second time on the same Thread instance, whether it's still running or already finished, throws IllegalThreadStateException . Thread t = new Thread(() -> doWork()); t.start(); t.start(); // throws IllegalThreadStateException This is because a Thread object's lifecycle is...
36. Explain the lifecycle of a virtual thread in Java 21?
A virtual thread's lifecycle looks like an ordinary thread's from the outside, it goes through NEW, RUNNABLE, and TERMINATED, plus WAITING/TIMED_WAITING/BLOCKED as needed, but the mechanics underneath are different. flowchart LR A[Created via Thread.ofVirtual] --> B[Scheduled onto a carrier platf
37. Explain the internal working of structured concurrency in Java 21?
Structured concurrency, previewed in Java 21 via StructuredTaskScope (JEP 453), applies the idea of structured programming to concurrent tasks: a group of subtasks forked within a scope must all complete, be cancelled, or fail together, before the scope itself completes,...
38. Why does a synchronized block pin a virtual thread to its carrier thread?
Normally, when a virtual thread blocks, the JVM unmounts it from its carrier and frees that carrier to run other virtual threads. Pinning is the exception: while a virtual thread is inside a synchronized block or method, or executing a...
39. What is the difference between ScopedValue and ThreadLocal?
ThreadLocal ScopedValue (preview, Java 21+) Mutable: set() can be called any number of times. Bound once for the duration it's active, via where().run() or call()....
40. Explain the internal working of the ForkJoinPool work-stealing algorithm?
Each worker thread in a ForkJoinPool owns its own double-ended queue (deque) of tasks rather than pulling from one shared queue. flowchart TB W1[Worker 1 deque] -->|push/pop from head| W1 W2[Worker 2 deque] -->|push/pop from head| W2 W2 -.steal from...
41. How can you optimize code to avoid false sharing?
False sharing happens when independent variables used by different threads happen to sit in the same CPU cache line, typically 64 bytes. Even though the threads never touch the same variable, one thread's write invalidates the entire cache line in...
42. Why does LongAdder outperform AtomicLong under high contention?
AtomicLong funnels every thread's update through compare-and-swap on a single shared 64-bit value. Under light contention that's cheap, but as thread count and update frequency rise, most CAS attempts fail because another thread has already changed the value, forcing repeated...
43. Why does the ABA problem occur in lock-free CAS-based algorithms?
A plain compare-and-swap only checks whether a memory location's current value still equals the expected value; it has no way to know whether that value changed and then changed back in between the read and the CAS. sequenceDiagram participant T1...
44. Explain the execution flow of a parallel stream operation?
Calling .parallelStream() or .stream().parallel() doesn't run your pipeline on one thread per element; it decomposes the source into chunks and submits the work to the common ForkJoinPool . flowchart TD A[Source: e.g....
45. How do you troubleshoot a deadlock in a production Java application?
The first step is capturing a thread dump of the running JVM at the moment it's hung, since a deadlock leaves the involved threads permanently blocked, so the dump captures the exact stuck state. jstack <pid> # or: kill -3...
46. What is the difference between StampedLock and ReadWriteLock?
ReentrantReadWriteLock StampedLock Read lock and write lock, both truly acquired and held. Adds a third mode: optimistic read, which takes no lock at all....
47. Which is better for high-throughput I/O - platform or virtual threads, and why?
For workloads dominated by blocking I/O, such as a typical web service making blocking database or HTTP calls per request, virtual threads are the better fit in Java 21. Platform threads map one-to-one to OS threads, which are expensive to...
48. How can you optimize a thread pool for mixed CPU-bound and I/O-bound workloads?
A single shared thread pool tuned for one kind of workload tends to perform badly on the other: a small pool sized for CPU-bound work leaves I/O-bound tasks queued unnecessarily since they spend most of their time waiting, not computing,...
49. Explain the internal working of AbstractQueuedSynchronizer (AQS)?
AbstractQueuedSynchronizer is the framework that most of java.util.concurrent 's locks and synchronizers, including ReentrantLock , Semaphore , CountDownLatch , and ReentrantReadWriteLock , are built on top of, so understanding it explains how they all share consistent, correct behavior. flowchar
50. Why doesn't increasing the thread pool size always improve throughput?
Adding more threads only helps while there's a genuine resource, whether CPU cores, I/O bandwidth, or a downstream service, that those extra threads can actually put to use. Once a workload's real bottleneck is saturated, more threads just add overhead...
