Interview Questions and Answers
Freshers / Beginner level questions & answers
Ques 1. What is multithreading?
Multithreading is the concurrent execution of two or more threads to achieve parallelism in a program.
Example:
In Java, you can create a multithreaded program by extending the Thread class or implementing the Runnable interface.
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 2. How do you create a thread in Java?
You can create a thread by extending the Thread class or implementing the Runnable interface.
Example:
Example using Thread class:
class MyThread extends Thread {
public void run() {
/* Thread logic */
}
}
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 3. What is the purpose of the sleep() method in Java?
The sleep() method is used to pause the execution of the current thread for a specified amount of time.
Example:
try { Thread.sleep(1000); }
catch (InterruptedException e) { e.printStackTrace(); }
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 4. What is the purpose of the yield() method?
The yield() method is used to make the currently executing thread voluntarily pause, allowing other threads to execute.
Example:
Thread.yield();
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Intermediate / 1 to 5 years experienced level questions & answers
Ques 5. 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 6. 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 7. 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 8. 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 9. 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 10. 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 11. 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 12. 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 13. 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 14. 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 15. 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 16. 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 17. 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 18. 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 19. 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 */ );
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Experienced / Expert level questions & answers
Ques 20. What is deadlock in multithreading?
Deadlock is a situation where two or more threads are blocked forever, waiting for each other to release the locks.
Example:
Thread 1 locks resource A and waits for resource B. Thread 2 locks resource B and waits for resource A.
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 21. Explain the concept of the wait-notify mechanism.
The wait-notify mechanism is used for inter-thread communication, where one thread can signal the other that a certain condition has been met.
Example:
Using wait(), notify(), and notifyAll() methods in synchronized blocks.
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 22. How does the join() method work in Java?
The join() method is used to wait for a thread to die. It causes the current thread to pause execution until the specified thread completes its execution.
Example:
Thread anotherThread = new Thread(() -> {
/* Thread logic */ });
anotherThread.start();
anotherThread.join();
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 23. Explain the concept of a race condition.
A race condition occurs when two or more threads access shared data concurrently, and the final outcome depends on the order of execution.
Example:
When two threads increment a shared counter without proper synchronization.
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 24. What is the ReentrantLock class in Java?
The ReentrantLock class is a part of the java.util.concurrent package and provides a flexible locking mechanism with the ability to interrupt a thread that is waiting for the lock.
Example:
ReentrantLock lock = new ReentrantLock();
lock.lock();
try { /* Critical section */ }
finally { lock.unlock(); }
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 25. Explain the concept of the producer-consumer problem in multithreading.
The producer-consumer problem involves two types of threads: producers that produce data and consumers that consume the data. The challenge is to synchronize their activities.
Example:
Using a shared buffer and synchronization mechanisms to ensure proper communication between producers and consumers.
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 26. Explain the concept of thread dumping.
Thread dumping involves generating a snapshot of all the threads' current state and stack traces. It is useful for diagnosing performance or deadlock issues.
Example:
In Java, you can use tools like jstack or VisualVM to generate thread dumps.
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 27. Explain the concept of the happens-before relationship in Java.
The happens-before relationship is a partial ordering of memory operations in Java. It ensures that the result of one operation is visible to another, providing a consistent view of shared data among threads.
Example:
Using synchronized blocks establishes a happens-before relationship.
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 28. What is the purpose of the Phaser class in Java?
The Phaser class in Java provides a more flexible alternative to the CountDownLatch and CyclicBarrier for synchronizing threads. It supports dynamic registration of threads and phase advancement.
Example:
Phaser phaser = new Phaser();
phaser.register(); // Register the current thread
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 29. What is the purpose of the Exchanger class in Java?
The Exchanger class provides a synchronization point at which threads can pair and swap elements within pairs. Each thread presents some object on entry to the exchange method, matches with a partner thread, and receives its partner's object on return.
Example:
Exchangerexchanger = new Exchanger<>();
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Ques 30. Explain the concept of the ForkJoinPool in Java.
The ForkJoinPool is a special-purpose ExecutorService designed for parallelizing divide-and-conquer algorithms. It is particularly useful for recursive tasks with multiple subtasks.
Example:
RecursiveTask and RecursiveAction are classes commonly used with ForkJoinPool.
保存以便复习
保存以便复习
收藏此条目、标记为困难题,或将其加入复习集合。
Most helpful rated by users:
- What is multithreading?
- What is the purpose of the yield() method?
- What is the purpose of the sleep() method in Java?
- How do you create a thread in Java?
- Explain the difference between Thread and Runnable.