Java Multithreading Interview Questions and Answers
Intermediate / 1 to 5 years experienced level questions & answers
Ques 1. Explain the difference between Thread and Runnable.
Thread is a class in Java that provides methods to create and perform operations on a thread. Runnable is an interface that must be implemented by a class to be executed by a thread.
Example:
class MyRunnable implements Runnable {
public void run()
{ /* Runnable logic */
}
}
Ques 2. How can you achieve synchronization in Java?
You can achieve synchronization in Java using the synchronized keyword or using locks.
Example:
Example using synchronized keyword:
synchronized void myMethod() { /* Synchronized code */ }
Ques 3. Explain the concept of thread safety.
Thread safety is a property that ensures that a block of code or a class can be safely executed by multiple threads concurrently without causing data corruption.
Example:
Using synchronized methods or blocks to control access to shared resources.
Ques 4. What is the Thread Pool in Java?
A Thread Pool is a group of pre-initialized, reusable threads that are available to perform a set of tasks.
Example:
ExecutorService executor = Executors.newFixedThreadPool(5);
Ques 5. Explain the significance of the volatile keyword in Java.
The volatile keyword in Java is used to indicate that a variable's value may be changed by multiple threads simultaneously.
Example:
volatile int sharedVariable = 0;
Ques 6. What is a daemon thread in Java?
A daemon thread is a background thread that runs intermittently and is terminated when all non-daemon threads have completed.
Example:
Thread daemonThread = new Thread(() -> {
/* Daemon thread logic */ });
daemonThread.setDaemon(true);
Ques 7. What is the purpose of the interrupt() method?
The interrupt() method is used to interrupt the execution of a thread. It sets the interrupted flag, causing the thread to stop if it's in a sleeping or waiting state.
Example:
Thread myThread = new Thread(() -> {
while (!Thread.interrupted()) {
/* Thread logic */
}
});
myThread.start();
myThread.interrupt();
Ques 8. Explain the concept of thread local variables.
Thread-local variables are variables that are local to each thread, and each thread has its own copy of the variable.
Example:
ThreadLocalthreadLocalVariable = new ThreadLocal<>();
threadLocalVariable.set("Value");
Ques 9. What is the Executor framework in Java?
The Executor framework provides a higher-level replacement for managing threads. It decouples the task creation and execution, allowing better control over thread management.
Example:
Executor executor = Executors.newFixedThreadPool(3);
executor.execute(() -> { /* Task logic */ });
Ques 10. What is the purpose of the notify() method in Java?
The notify() method is used to wake up a single thread that is waiting on an object's monitor. It is part of the wait-notify mechanism for inter-thread communication.
Example:
synchronized (sharedObject) {
sharedObject.notify();
}
Ques 11. How does the ConcurrentHashMap differ from HashMap in terms of multithreading?
ConcurrentHashMap is designed for multithreaded access and allows concurrent reads without blocking, while HashMap is not thread-safe and may lead to inconsistencies in a multithreaded environment.
Example:
ConcurrentMapconcurrentMap = new ConcurrentHashMap<>();
Ques 12. What is the purpose of the AtomicInteger class in Java?
AtomicInteger is a class in Java that provides atomic operations for integer variables, ensuring that operations on the variable are performed atomically without interference from other threads.
Example:
AtomicInteger counter = new AtomicInteger(0); counter.incrementAndGet();
Ques 13. Explain the concept of thread starvation.
Thread starvation occurs when a thread is unable to gain access to a resource or the CPU, preventing it from making progress. It is often caused by improper synchronization or priority mismanagement.
Example:
When low-priority threads continuously preempt high-priority threads.
Ques 14. Explain the concept of the ReadWriteLock interface in Java.
The ReadWriteLock interface provides a lock that allows multiple threads to read a resource simultaneously but only one thread to write to the resource at any given time.
Example:
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
Ques 15. What is the purpose of the CompletableFuture class in Java?
CompletableFuture is a class in Java that represents a promise to complete an asynchronous computation. It provides a flexible way to compose, combine, and manage asynchronous operations.
Example:
CompletableFuture.supplyAsync(() -> /* Asynchronous computation */ ).thenApply(result -> /* Process result */ );
Most helpful rated by users: