Race condition in thread pool

**ROOT CAUSE ANALYSIS** The deadlock during thread pool shutdown occurs due to a race condition between the shutdown process and worker threads. Key reasons include: 1. **Blocking Operations During Shutdown**: Worker threads may be executing long-running tasks that hold locks or resources required by the shutdown procedure. 2. **Synchronization Issues**: The shutdown mechanism (e.g., `shutdown()` or `awaitTermination()`) may block indefinitely while worker threads are processing tasks that cannot be interrupted. 3. **Resource Contention**: Worker threads might be waiting for resources (e.g., database connections, file handles) that are being accessed during shutdown, creating circular dependencies. 4. **Interrupt Handling**: Worker threads may not properly respond to interrupts if they are in blocking calls (e.g., `Thread.sleep()` or I/O operations), causing them to remain active. This race condition leads to a deadlock where the shutdown procedure is waiting for worker threads to complete, while worker threads are waiting for resources or locks that the shutdown procedure controls. --- **CODE FIX** ```java import java.util.concurrent.*; import java.util.List; import java.util.ArrayList; public class ThreadPool { private final BlockingQueue taskQueue; private final List workers; private volatile boolean isShutdown; private final Object lock = new Object(); public ThreadPool(int nThreads) { taskQueue = new LinkedBlockingQueue<>(); workers = new ArrayList<>(); for (int i = 0; i < nThreads; i++) { WorkerThread worker = new WorkerThread(); worker.start(); workers.add(worker); } } public void execute(Runnable task) { synchronized (lock) { taskQueue.add(task); lock.notifyAll(); } } public void shutdown() { synchronized (lock) { isShutdown = true; lock.notifyAll(); } // Interrupt all worker threads for (WorkerThread worker : workers) { worker.interrupt(); } // Wait for threads to exit gracefully for (WorkerThread worker : workers) { try { worker.join(60); // 60-second timeout } catch (InterruptedException e) { // Handle interruption } } } private class WorkerThread extends Thread { @Override public void run() { while (!isShutdown()) { Runnable task; synchronized (ThreadPool.this.lock) { try { task = ThreadPool.this.taskQueue.poll(); if (task == null) { ThreadPool.this.lock.wait(); // Wait for new tasks } } catch (InterruptedException e) { // Check shutdown flag on interruption if (isShutdown()) { break; } } } if (task != null) { try { task.run(); } catch (Throwable t) { // Handle exceptions } } } } private boolean isShutdown() { synchronized (ThreadPool.this.lock) { return ThreadPool.this.isShutdown; } } } // Example usage with shutdown hook public static void main(String[] args) { ThreadPool pool = new ThreadPool(10); // Submit tasks... Runtime.getRuntime().addShutdownHook(new Thread(() -> { pool.shutdown(); System.out.println("ThreadPool shutdown initiated."); })); } } ``` **Changes Made:** 1. **Graceful Shutdown**: Added `isShutdown` flag and synchronization to break worker loops. 2. **Interrupt Handling**: Worker threads check `isShutdown()` on each iteration and respond to `interrupt()`. 3. **Timeout Mechanism**: Worker threads wait for new tasks with a timeout to avoid indefinite blocking. 4. **Shutdown Hook**: Added a shutdown hook to initiate cleanup without blocking the main application. 5. **Resource Cleanup**: Ensures threads exit promptly during shutdown, avoiding deadlock-prone blocking calls. This fix ensures the thread pool terminates without deadlock by decoupling shutdown signaling from worker execution and using timeouts to prevent indefinite blocking.