Common Java Multithreading and Concurrency Interview Questions and Answers

Multithreading and concurrency issues are among the topics interviewers like to ask in Java technical interviews. Here, from an interview perspective, most important questions are listed, but you should still master Java multithreading fundamentals to handle future problems.

Java Multithreading Interview Questions

1. What is the difference between a process and a thread?

A process is an independent execution environment, essentially a program or application, while a thread is a task that runs within a process. In Java, the runtime is a single process containing many classes and programs. Threads are lightweight processes that require fewer resources to create and reside within a process, and they can share the process's resources.

2. What are the benefits of multithreaded programming?

In a multithreaded program, multiple threads execute concurrently to improve efficiency, preventing the CPU from idling while waiting for resources. Threads share heap memory, so creating multiple threads to perform tasks is better than creating multiple processes. For example, Servlets are superior to CGI because Servlets support multithreading while CGI does not.

3. What is the difference between user threads and daemon threads?

A thread created in a Java program is a user thread. A daemon thread runs in the background and does not prevent the JVM from terminating. When no user threads are running, the JVM shuts down the program. Child threads created by a daemon thread are also daemon threads.

4. How do we create a thread?

There are two ways: implement the Runnable interface and pass an instance to the Thread constructor, or directly extend the Thread class.

5. What are the different thread life‑cycle states?

When a thread is newly created, its state is New. Calling start() changes the state to Runnable. The thread scheduler allocates CPU time to Runnable threads, changing their state to Running.

6. Can we call Thread.run() directly?

Yes, but calling run() executes like a normal method in the current thread. To execute code in a new thread, you must use Thread.start().

7. How can we pause a running thread for a period of time?

Use Thread.sleep() to pause a thread. The thread does not terminate; after waking, its state becomes Runnable and it will be scheduled for execution.

8. What is your understanding of thread priority?

Each thread has a priority (typically 1–10). Higher‑priority threads generally have preference, but this depends on the OS scheduler. Priority is an int value; 1 is lowest, 10 is highest, but priority does not guarantee execution order.

9. What are Thread Scheduler and Time Slicing?

The thread scheduler is an OS service that allocates CPU time to Runnable threads. Time slicing distributes available CPU time among Runnable threads, possibly based on priority or waiting time. Thread scheduling is not controlled by the JVM; applications should not rely on priority.

10. What is context switching in multithreading?

Context switching is the process of storing and restoring CPU state so that a thread can resume execution from the point it was interrupted. It is a fundamental feature of multitasking operating systems and multithreaded environments.

11. How do you ensure the thread running the main() method is the last to finish?

Use Thread.join() to make the main thread wait for other threads to finish before exiting.

12. How do threads communicate with each other?

When threads share resources, communication is essential. The Object class methods wait(), notify(), and notifyAll() are used to coordinate lock states between threads.

13. Why are wait(), notify() and notifyAll() defined in the Object class?

Every Java object has a monitor (lock). These methods operate on the object's monitor, allowing any class to use them for thread communication.

14. Why must wait(), notify() and notifyAll() be called inside synchronized methods or blocks?

A thread must hold the object's lock to call wait(); it releases the lock and enters waiting state until another thread calls notify(). Similarly, notify() releases the lock so waiting threads can acquire it. Because these methods require the lock, they must be invoked within synchronized contexts.

15. Why are Thread.sleep() and Thread.yield() static methods?

They operate on the currently executing thread, so calling them on other threads would be meaningless. Being static ensures they affect the thread that invokes them.

16. How do you ensure thread safety?

Java provides several mechanisms: synchronized blocks/methods, atomic classes, explicit locks, the volatile keyword, immutable objects, and thread‑safe library classes.

17. What is the purpose of the volatile keyword in Java?

When a variable is declared volatile, all threads read its latest value directly from main memory, ensuring visibility of changes across threads.

18. Which is better: synchronized methods or synchronized blocks?

Synchronized blocks are generally preferred because they can lock only the necessary portion of code, avoiding the overhead of locking the entire object.

19. How do you create a daemon thread?

Call Thread.setDaemon(true) before invoking start(); otherwise an IllegalThreadStateException is thrown.

20. What is ThreadLocal?

ThreadLocal provides thread‑local variables. Each thread has its own independent copy, avoiding the need for synchronization when thread‑specific data is required.

Each thread owns its own ThreadLocal variable and can get or set its value via get() and set() methods. ThreadLocal instances are often declared as private static fields.

21. What is a ThreadGroup and why is it recommended?

ThreadGroup is a class that groups threads together, providing information about the group. However, its API is limited and many of its functions are superseded by Thread’s setUncaughtExceptionHandler, making ThreadGroup largely obsolete.

t1.setUncaughtExceptionHandler(new UncaughtExceptionHandler(){

@Override
public void void uncaughtException(Thread t, Throwable e) {
System.out.println("exception occured:"+e.getMessage());
}

});

22. What is a Java thread dump and how can you obtain it?

A thread dump is a list of all active JVM threads, useful for analyzing bottlenecks and deadlocks. It can be obtained via profilers, the kill -3 command, jstack, etc. jstack is convenient because it ships with the JDK.

23. What is a deadlock and how can it be analyzed and avoided?

A deadlock occurs when two or more threads are permanently blocked, each waiting for a resource held by another. Analyzing a thread dump for BLOCKED threads and their waiting resources helps identify deadlocks. Avoid nested locks, lock only when necessary, and avoid indefinite waiting.

24. What is the Java Timer class and how do you create a task with a specific interval?

java.util.Timer schedules a thread to execute a task at a future time, either once or periodically.

java.util.TimerTask is an abstract class implementing Runnable; you extend it to define your timed task and schedule it with a Timer.

25. What is a thread pool and how do you create one in Java?

A thread pool manages a set of worker threads and a queue of pending tasks.

The java.util.concurrent.Executors class provides implementations of the Executor interface for creating thread pools, including examples like ScheduledThreadPoolExecutor for periodic tasks.

Java Concurrency Interview Questions

1. What is an atomic operation? Which atomic classes exist in the Java Concurrency API?

An atomic operation is a unit of work that is indivisible and unaffected by other operations, essential for data consistency in multithreaded environments.

int++ is not atomic; concurrent increments can lead to errors.

Since JDK 1.5, the java.util.concurrent.atomic package provides atomic wrapper classes for int and long that guarantee atomicity without explicit synchronization.

2. What is the Lock interface in the Java Concurrency API and what advantages does it have over synchronized?

Lock offers more flexible locking, allowing fairness policies, interruptible lock acquisition, timed tryLock, and multiple lock acquisition/release patterns.

3. What is the Executors framework?

The Executors framework, introduced with java.util.concurrent.Executor in Java 5, provides a way to schedule, execute, and control asynchronous tasks.

Creating a thread pool limits the number of threads and enables thread reuse, which prevents memory overflow from unlimited thread creation.

4. What is a blocking queue and how can it be used to implement a producer‑consumer model?

java.util.concurrent.BlockingQueue blocks retrieval when the queue is empty and blocks insertion when the queue is full, supporting thread‑safe operations.

It does not accept null values (throws NullPointerException) and its implementations are thread‑safe with atomic methods.

BlockingQueue is part of the Java Collections framework and is commonly used for producer‑consumer problems.

5. What are Callable and Future?

Callable, introduced in Java 5, is similar to Runnable but can return a result and throw exceptions.

Executors can submit Callable tasks, returning a Future object that allows checking task status and retrieving the result via get().

6. What is FutureTask?

FutureTask is a concrete implementation of Future that can be used with Executors for asynchronous processing. It can be subclassed to customize behavior.

7. What are concurrent containers?

Java collection classes are fail‑fast; modifying a collection while iterating throws ConcurrentModificationException.

Concurrent containers support concurrent iteration and updates. Main classes include ConcurrentHashMap, CopyOnWriteArrayList, and CopyOnWriteArraySet.

8. What is the Executors class?

Executors provides utility methods for creating Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable instances, simplifying thread‑pool creation.

Original source: http://ifeve.com/java-multi-threading-concurrency-interview-questions-with-answers/

If you encounter problems while learning Java or want resources, feel free to join the Java study group QQ: 589809992.