Java Multithreading Interview Questions 2026: 28 Q&A

Last Updated: June 2026 | Level: Freshers to Mid-Level | Read Time: ~17 min

Concurrency separates strong Java candidates from average ones. Candidates report that product-company loops dig into the Java Memory Model, volatile, and the java.util.concurrent toolkit, while service companies stick to thread lifecycle, synchronized, and wait/notify. This guide covers 28 multithreading questions with full answers and runnable code. Behaviour reflects the official Oracle concurrency docs; confirm any memory-model nuance against the JLS chapter 17, since this is the area candidates most often get subtly wrong.

Pair this with Java Interview Questions 2026 and Java OOPs Interview Questions 2026.

Table of Contents

1. Thread Basics (Q1 to Q9)
2. Synchronization and Locks (Q10 to Q18)
3. Memory Model and volatile (Q19 to Q23)
4. Executors and High-Level API (Q24 to Q28)
5. Predict the Output
6. Quick Revision Table
7. Frequently Asked Questions

Thread Basics

Q1. What is a thread and how is it different from a process? Easy

Q2. What are the ways to create a thread in Java? Easy

Thread t = new Thread(() -> System.out.println("running"));
t.start();

Q3. What is the difference between start() and run()? Easy

Q4. What are the states in a thread's lifecycle? Medium

Q5. What is the difference between wait() and sleep()? Medium

Q6. What does join() do? Easy

Q7. What is a daemon thread? Medium

Q8. What is thread priority and is it reliable? Medium

Q9. Why is calling Thread.stop() discouraged? Hard

Synchronization and Locks

Q10. What is a race condition? Medium

Q11. What does the synchronized keyword do? Medium

synchronized (lock) {
    count++;            // mutual exclusion + visibility
}

Q12. What is the difference between a synchronized method and a synchronized block? Medium

Q13. What is a deadlock and how do you prevent it? Hard

Q14. What is the difference between deadlock, livelock, and starvation? Hard

Q15. What is a ReentrantLock and how does it differ from synchronized? Hard

lock.lock();
try { /* critical section */ }
finally { lock.unlock(); }

Q16. What is the difference between wait/notify and Condition? Hard

Q17. What is the producer-consumer problem? Medium

BlockingQueue<Integer> q = new ArrayBlockingQueue<>(10);
q.put(1);          // blocks if full
int v = q.take();  // blocks if empty

Q18. Why should you always check a condition in a while loop with wait()? Hard

Memory Model and volatile

Q19. What is the Java Memory Model? Hard

Q20. What does volatile guarantee? Hard

volatile boolean running = true;   // visible stop flag across threads

Q21. Why is volatile not enough for count++? Hard

Q22. What are atomic classes? Medium

AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();   // atomic, no lock

Q23. What is the happens-before relationship? Hard

Executors and High-Level API

Q24. What is the ExecutorService and why use it? Medium

ExecutorService pool = Executors.newFixedThreadPool(4);
Future<Integer> f = pool.submit(() -> 42);
int result = f.get();
pool.shutdown();

Q25. What is the difference between submit() and execute()? Medium

Q26. What is a Callable and how is it different from Runnable? Medium

Q27. What is a CompletableFuture? Hard

CompletableFuture.supplyAsync(() -> fetch())
                 .thenApply(this::parse)
                 .thenAccept(System.out::println);

Q28. What are virtual threads (Project Loom)? Hard

Predict the Output

Snippet 1

int[] count = {0};
Runnable task = () -> { for (int i = 0; i < 1000; i++) count[0]++; };
Thread t1 = new Thread(task), t2 = new Thread(task);
t1.start(); t2.start();
t1.join(); t2.join();
System.out.println(count[0]);

Output:

(some value <= 2000, often less than 2000)

Why: count[0]++ is not atomic and the array is not synchronised, so updates are lost to the race. The result is non-deterministic and usually below 2000. Use AtomicInteger to get exactly 2000.

Snippet 2

Thread t = new Thread(() -> System.out.println("child"));
t.run();
System.out.println("main");

Output:

child
main

Why: Calling run() directly executes on the main thread synchronously before "main" prints. Only start() would create a real concurrent thread.

Snippet 3

ExecutorService pool = Executors.newFixedThreadPool(2);
Future<Integer> f = pool.submit(() -> 10 / 0);
try { f.get(); }
catch (Exception e) { System.out.println(e.getClass().getSimpleName()); }
pool.shutdown();

Output:

ExecutionException

Why: An exception thrown inside a submitted task is wrapped in an ExecutionException and surfaced when you call f.get(), not at submission time.

Quick Revision Table

Frequently Asked Questions

Is multithreading asked to freshers in 2026?

Candidates report that service companies ask basic thread lifecycle, synchronized, and the difference between wait and sleep, while product companies probe the Java Memory Model, volatile, and the ExecutorService API. Prepare both levels.

What is the most common concurrency gotcha in interviews?

The classic trap is assuming volatile makes count++ atomic. It does not, volatile only guarantees visibility and ordering. Use AtomicInteger or a lock for any compound update.

Should I use Thread or Runnable to create threads?

Prefer a Runnable or lambda passed to a Thread, or better, an ExecutorService. Extending Thread couples your task to the thread and consumes your single inheritance slot.

What is the difference between concurrency and parallelism?

Concurrency is dealing with many tasks by interleaving them, even on one core. Parallelism is literally running tasks at the same instant on multiple cores. Interviewers like this distinction as a warm-up.

How do virtual threads change concurrency design?

Virtual threads make the simple blocking style scale to millions of tasks, reducing the need for callback-heavy async code. You still need correct synchronisation, but thread cost stops being the bottleneck.

Related Articles

• Java Interview Questions 2026, the master 50-question set
• Java OOPs Interview Questions 2026, OOP foundations
• Java Collections Interview Questions 2026, thread-safe collections covered
• Operating Systems Interview Questions 2026, threads and scheduling theory

Confirm any Java Memory Model or version-specific behaviour against the official JLS and Oracle concurrency docs before your interview. This guide reflects candidate-reported patterns and public preparation resources as of June 2026.