{"type":"doc","content":[{"type":"image","attrs":{"src":"https://miro.medium.com/v2/resize:fit:700/1*zdAVkUjIM9VHkYjG88pobA.png","alt":"","title":null}},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"Key Topics"}]},{"type":"orderedList","attrs":{"tight":true,"start":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Introduction to Concurrency"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Creating Threads in Java"}]}]}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Extending the Thread Class"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Implementing the Runnable Interface"}]}]}]},{"type":"paragraph","content":[{"type":"text","text":"3. Thread Lifecycle"}]},{"type":"paragraph","content":[{"type":"text","text":"4. Synchronization"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Synchronized Methods"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Synchronized Blocks"}]}]}]},{"type":"paragraph","content":[{"type":"text","text":"5. Thread Safety with Locks"}]},{"type":"paragraph","content":[{"type":"text","text":"6. Executor Framework"}]},{"type":"paragraph","content":[{"type":"text","text":"7. Interview Questions and Answers"}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"Introduction to Concurrency"}]},{"type":"paragraph","content":[{"type":"text","text":"Concurrency allows multiple tasks to run simultaneously, improving application performance and responsiveness. Java provides robust support for concurrency through its threading model, enabling developers to execute tasks in parallel, manage shared resources, and handle synchronization."}]},{"type":"paragraph","content":[{"type":"text","text":"Key concepts:"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread"},{"type":"text","text":": The smallest unit of execution in a Java program."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Concurrency"},{"type":"text","text":": Running multiple threads simultaneously, either on a single CPU (via time-slicing) or multiple CPU cores."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Safety"},{"type":"text","text":": Ensuring shared resources are accessed safely by multiple threads."}]}]}]},{"type":"paragraph","content":[{"type":"text","text":"This tutorial demonstrates how to create and manage threads, synchronize access to shared resources, and use high-level concurrency utilities."}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"Creating Threads in Java"}]},{"type":"paragraph","content":[{"type":"text","text":"Java offers two primary ways to create threads: extending the Thread class or implementing the Runnable interface."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Extending the Thread Class"}]},{"type":"paragraph","content":[{"type":"text","text":"You can create a thread by extending the Thread class and overriding its run() method."}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"class MyThread extends Thread {\n @Override\n public void run() {\n for (int i = 1; i <= 5; i++) {\n System.out.println(Thread.currentThread().getName() + \" printing: \" + i);\n try {\n Thread.sleep(500); // Simulate work with a delay\n } catch (InterruptedException e) {\n System.out.println(\"Thread interrupted: \" + e.getMessage());\n }\n }\n }\n}\n\npublic class ThreadExample {\n public static void main(String[] args) {\n MyThread thread1 = new MyThread();\n MyThread thread2 = new MyThread();\n thread1.start(); // Start the first thread\n thread2.start(); // Start the second thread\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"The MyThread class extends Thread and defines the task in the run() method."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"The start() method initiates the thread, invoking run() in a separate execution path."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Output shows interleaved execution of thread1 and thread2, demonstrating concurrent behavior."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Implementing the Runnable Interface"}]},{"type":"paragraph","content":[{"type":"text","text":"The Runnable interface is preferred when you want to separate the task from the thread management or extend another class."}]},{"type":"paragraph","content":[{"type":"text","text":"The "},{"type":"text","marks":[{"type":"code"}],"text":"Runnable"},{"type":"text","text":" interface is used to define a task that can be executed by a thread, without directly managing the thread itself. It's especially useful when your class already extends another class, since Java doesn't support multiple inheritance. By implementing "},{"type":"text","marks":[{"type":"code"}],"text":"Runnable"},{"type":"text","text":", you keep task logic separate from thread creation, promoting cleaner and more flexible code design."}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"class MyRunnable implements Runnable {\n @Override\n public void run() {\n for (int i = 1; i <= 5; i++) {\n System.out.println(Thread.currentThread().getName() + \" printing: \" + i);\n try {\n Thread.sleep(500);\n } catch (InterruptedException e) {\n System.out.println(\"Thread interrupted: \" + e.getMessage());\n }\n }\n }\n}\n\npublic class RunnableExample {\n public static void main(String[] args) {\n Thread thread1 = new Thread(new MyRunnable());\n Thread thread2 = new Thread(new MyRunnable());\n thread1.start();\n thread2.start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"MyRunnable implements Runnable and defines the task in run()."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"A Thread object is created with the Runnable instance and started."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"This approach promotes better code reuse and flexibility."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Lifecycle"}]},{"type":"paragraph","content":[{"type":"text","text":"A thread in Java goes through several states:"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"New"},{"type":"text","text":": Created but not started."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Runnable"},{"type":"text","text":": Ready to run or running."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Blocked/Waiting"},{"type":"text","text":": Waiting for a resource or monitor lock."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Timed Waiting"},{"type":"text","text":": Waiting for a specified time (e.g., via sleep() or wait(timeout))."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Terminated"},{"type":"text","text":": Completed execution or stopped."}]}]}]},{"type":"paragraph","content":[{"type":"text","text":"Understanding the lifecycle helps manage threads effectively, especially when coordinating tasks."}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"Synchronization"}]},{"type":"paragraph","content":[{"type":"text","text":"When multiple threads access shared resources (like a shared counter), they can interfere with each other, causing race conditions or inconsistent results. Synchronization ensures that only one thread accesses the critical section of code at a time. In Java, this can be done using the "},{"type":"text","marks":[{"type":"code"}],"text":"synchronized"},{"type":"text","text":" keyword."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Synchronized Methods"}]},{"type":"paragraph","content":[{"type":"text","text":"The synchronized keyword ensures only one thread executes a method at a time."}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"class Counter {\n private int count = 0;\n\n public synchronized void increment() {\n count++;\n }\n\n public synchronized int getCount() {\n return count;\n }\n}\n\npublic class SynchronizedMethodExample {\n public static void main(String[] args) throws InterruptedException {\n Counter counter = new Counter();\n Runnable task = () -> {\n for (int i = 0; i < 1000; i++) {\n counter.increment();\n }\n };\n\n Thread thread1 = new Thread(task);\n Thread thread2 = new Thread(task);\n thread1.start();\n thread2.start();\n thread1.join(); // Wait for thread1 to finish\n thread2.join(); // Wait for thread2 to finish\n System.out.println(\"Final count: \" + counter.getCount());\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"The increment() method is synchronized, ensuring thread-safe updates to count."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Without synchronization, the final count might be less than 2000 due to race conditions."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Output will consistently show Final count: 2000."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Synchronized Blocks"}]},{"type":"paragraph","content":[{"type":"text","text":"For finer control, use synchronized blocks to lock specific objects"}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"class CounterBlock {\n private int count = 0;\n private final Object lock = new Object();\n\n public void increment() {\n synchronized (lock) {\n count++;\n }\n }\n\n public int getCount() {\n synchronized (lock) {\n return count;\n }\n }\n}\n\npublic class SynchronizedBlockExample {\n public static void main(String[] args) throws InterruptedException {\n CounterBlock counter = new CounterBlock();\n Runnable task = () -> {\n for (int i = 0; i < 1000; i++) {\n counter.increment();\n }\n };\n\n Thread thread1 = new Thread(task);\n Thread thread2 = new Thread(task);\n thread1.start();\n thread2.start();\n thread1.join();\n thread2.join();\n System.out.println(\"Final count: \" + counter.getCount());\n }\n}"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"The synchronized (lock) block ensures only one thread modifies count at a time."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Using a specific lock object reduces contention compared to synchronizing the entire method."}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Safety with Locks"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"textStyle","attrs":{"color":""}}],"text":"Press enter or click to view image in full size"}]},{"type":"image","attrs":{"src":"https://miro.medium.com/v2/resize:fit:700/1*I5hDWcLbEobzhZnQtA8y_g.png","alt":"","title":null}},{"type":"paragraph","content":[{"type":"text","text":"Cartoon generated by ChatGPT using prompts from author"}]},{"type":"paragraph","content":[{"type":"text","text":"Java’s java.util.concurrent.locks package provides explicit locks, offering more flexibility than synchronized."}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.locks.ReentrantLock;\n\nclass CounterLock {\n private int count = 0;\n private final ReentrantLock lock = new ReentrantLock();\n\n public void increment() {\n lock.lock();\n try {\n count++;\n } finally {\n lock.unlock();\n }\n }\n\n public int getCount() {\n lock.lock();\n try {\n return count;\n } finally {\n lock.unlock();\n }\n }\n}\n\npublic class LockExample {\n public static void main(String[] args) throws InterruptedException {\n CounterLock counter = new CounterLock();\n Runnable task = () -> {\n for (int i = 0; i < 1000; i++) {\n counter.increment();\n }\n };\n\n Thread thread1 = new Thread(task);\n Thread thread2 = new Thread(task);\n thread1.start();\n thread2.start();\n thread1.join();\n thread2.join();\n System.out.println(\"Final count: \" + counter.getCount());\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"ReentrantLock allows explicit locking and unlocking, ensuring thread safety."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"The try-finally block ensures the lock is released even if an exception occurs."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Locks offer advanced features like try-locking and fairness policies."}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"Executor Framework"}]},{"type":"paragraph","content":[{"type":"text","text":"The Executor framework (java.util.concurrent) simplifies thread management by abstracting thread creation and pooling"}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.ExecutorService;\nimport java.util.concurrent.Executors;\n\npublic class ExecutorExample {\n public static void main(String[] args) {\n ExecutorService executor = Executors.newFixedThreadPool(2);\n Runnable task = () -> {\n for (int i = 1; i <= 5; i++) {\n System.out.println(Thread.currentThread().getName() + \" printing: \" + i);\n try {\n Thread.sleep(500);\n } catch (InterruptedException e) {\n System.out.println(\"Thread interrupted: \" + e.getMessage());\n }\n }\n };\n\n executor.submit(task);\n executor.submit(task);\n executor.shutdown(); // Initiates orderly shutdown\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Executors.newFixedThreadPool(2) creates a thread pool with two threads."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Tasks are submitted to the executor, which manages thread allocation."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"shutdown() ensures the executor terminates after tasks complete."}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"Note on Locks and Executor Service"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Locks"},{"type":"text","text":" in Java provide more control over thread synchronization compared to the "},{"type":"text","marks":[{"type":"code"}],"text":"synchronized"},{"type":"text","text":" keyword. They solve problems like deadlock prevention, timed waits, and interruptible locks, which "},{"type":"text","marks":[{"type":"code"}],"text":"synchronized"},{"type":"text","text":" can't handle easily. For instance, "},{"type":"text","marks":[{"type":"code"}],"text":"ReentrantLock"},{"type":"text","text":" allows a thread to attempt acquiring a lock with a timeout or respond to interrupts while waiting. Locks are especially useful in complex scenarios where multiple threads need fine-grained control over resource access. Unlike "},{"type":"text","marks":[{"type":"code"}],"text":"synchronized"},{"type":"text","text":", Locks can also be acquired and released in different scopes, giving developers more flexibility. This makes them ideal for high-performance, multi-threaded applications requiring advanced coordination."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"ExecutorService"},{"type":"text","text":" solves the problem of manually creating and managing threads, which can lead to resource exhaustion and poor performance. It provides a framework for reusing a pool of threads, efficiently scheduling tasks, and managing their lifecycle. Instead of creating a new thread for each task, you submit tasks to the executor, which assigns them to available threads in the pool. This approach reduces overhead and improves scalability, especially under heavy loads. It also supports features like task scheduling, timeouts, and result retrieval through "},{"type":"text","marks":[{"type":"code"}],"text":"Future"},{"type":"text","text":". ExecutorService simplifies concurrent programming by decoupling task submission from thread management."}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"Interview Questions On Concurrency In Java"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"1. Explain the internal workings of the synchronized keyword in Java. How does it ensure thread safety, and what is the role of the monitor in this process?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":": The synchronized keyword ensures thread safety by enforcing mutual exclusion, allowing only one thread to execute a synchronized block or method at a time. It uses a "},{"type":"text","marks":[{"type":"bold"}],"text":"monitor"},{"type":"text","text":", an internal lock associated with every Java object, to control access. When a thread enters a synchronized block, it acquires the monitor of the specified object (or class for static methods). Other threads attempting to acquire the same monitor are blocked until the first thread releases it by exiting the block."}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Monitor Role"},{"type":"text","text":": The monitor maintains a lock state and a wait queue. It supports wait(), notify(), and notifyAll() for thread coordination."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Internals"},{"type":"text","text":": The JVM uses monitorenter and monitorexit instructions in bytecode to manage locking. Synchronization can occur on an object instance (synchronized(this)) or a class (synchronized(MyClass.class)). Synchronization on an object instance ("},{"type":"text","marks":[{"type":"code"}],"text":"synchronized(this)"},{"type":"text","text":") locks only that specific object, so other threads can access methods of other instances concurrently. Synchronization on a class ("},{"type":"text","marks":[{"type":"code"}],"text":"synchronized(MyClass.class)"},{"type":"text","text":") locks the entire class, blocking access to all synchronized static methods or blocks across all instances."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Safety"},{"type":"text","text":": By preventing concurrent access to critical sections, it ensures data consistency (e.g., avoiding race conditions)."}]}]}]},{"type":"paragraph","content":[{"type":"text","text":"Example : See above sections"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"2. What is the difference between ReentrantLock and synchronized? In what scenarios would you prefer using ReentrantLock over synchronized?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":": Both ReentrantLock and synchronized provide mutual exclusion, but ReentrantLock (from java.util.concurrent.locks) offers more flexibility."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Differences"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Granularity"},{"type":"text","text":": synchronized locks are implicit and scoped to a block/method; ReentrantLock allows explicit locking/unlocking with lock() and unlock()."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Features"},{"type":"text","text":": ReentrantLock supports fair locking (FIFO order), try-locking (tryLock()), timed locks, and condition variables (Condition)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Interruptibility"},{"type":"text","text":": ReentrantLock allows lock acquisition to be interrupted (lockInterruptibly()), unlike synchronized."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Performance"},{"type":"text","text":": Modern JVMs optimize synchronized well, but ReentrantLock can be tuned for specific use cases."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Error Handling"},{"type":"text","text":": ReentrantLock requires manual unlocking (typically in a finally block), while synchronized automatically releases locks."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"When to Use ReentrantLock"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Need advanced features like fair locking or try-locking."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Require interruptible locks or condition-based coordination."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Need to separate lock acquisition and release across methods."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Bottomline"},{"type":"text","text":": ReentrantLock ensures thread safety like synchronized but allows explicit control over locking."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"3. Describe the Java Memory Model (JMM). How does it define the happens-before relationship, and why is it critical for multithreaded applications?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":": The Java Memory Model (JMM) defines how threads interact with memory, ensuring consistent visibility of changes across threads. It specifies rules for reading/writing variables, synchronization, and volatile fields."}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Happens-Before Relationship"},{"type":"text","text":": A guarantee that memory writes by one thread are visible to another thread. Key rules include:"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Program Order"},{"type":"text","text":": Each action in a thread happens-before subsequent actions in the same thread."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Monitor Lock"},{"type":"text","text":": An unlock on a monitor happens-before a subsequent lock on the same monitor."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Volatile"},{"type":"text","text":": A write to a volatile field happens-before a subsequent read of that field."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Start/Join"},{"type":"text","text":": Starting a thread happens-before its actions; a thread’s actions happen-before its join completes."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Criticality"},{"type":"text","text":": Without JMM, threads might see stale or reordered data due to compiler optimizations or CPU caching. The happens-before relationship ensures predictable behavior in concurrent programs."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"public class VolatileExample {\n private volatile boolean flag = false;\n\n public void writer() {\n flag = true; // Write visible to all threads\n }\n\n public void reader() {\n if (flag) {\n System.out.println(\"Flag is true\");\n }\n }\n\n public static void main(String[] args) {\n VolatileExample example = new VolatileExample();\n Thread writer = new Thread(() -> example.writer());\n Thread reader = new Thread(() -> example.reader());\n writer.start();\n reader.start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation:"},{"type":"text","text":" The volatile keyword ensures the write to flag is visible to the reader thread, enforced by the JMM’s happens-before rule."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"4. What are the advantages and disadvantages of using the volatile keyword in Java? Can you provide a practical example where volatile is essential?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Advantages"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Ensures visibility: Writes to a volatile variable are immediately visible to all threads."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Prevents instruction reordering: Guarantees happens-before relationships."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Lightweight: No locking overhead, suitable for simple flags or state variables."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Disadvantages"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"No atomicity: Does not protect compound operations (e.g., i++)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Limited use: Only suitable for single-variable updates, not complex synchronization."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Potential misuse: Developers may overuse it instead of proper locks."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Practical Example"},{"type":"text","text":": A flag to stop a thread safely."}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"public class VolatileExample {\n private volatile boolean flag = false;\n\n public void writer() {\n flag = true; // Write visible to all threads\n }\n\n public void reader() {\n if (flag) {\n System.out.println(\"Flag is true\");\n }\n }\n\n public static void main(String[] args) {\n VolatileExample example = new VolatileExample();\n Thread writer = new Thread(() -> example.writer());\n Thread reader = new Thread(() -> example.reader());\n writer.start();\n reader.start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation: "},{"type":"text","text":"volatile ensures the stopped flag’s update is visible across threads, allowing safe termination."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"5. Explain the purpose of the ExecutorService framework. How does it simplify thread management compared to manually creating Thread objects?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":": The ExecutorService (part of java.util.concurrent) abstracts thread management, providing a high-level API to execute tasks asynchronously. It decouples task submission from thread creation and management."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Purpose"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Manages a pool of threads to execute tasks, reducing overhead of thread creation."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Supports task scheduling, execution, and lifecycle management (e.g., shutdown)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Provides utilities like submit(), invokeAll(), and schedule() for flexible task handling."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Simplification"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Reuse"},{"type":"text","text":": Reuses threads from a pool, avoiding repeated thread creation."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Task Abstraction"},{"type":"text","text":": Accepts Runnable or Callable tasks, focusing on logic rather than thread mechanics."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Scalability"},{"type":"text","text":": Configurable thread pools (e.g., fixed, cached) optimize resource usage."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Error Handling"},{"type":"text","text":": Simplifies exception handling via Future objects."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.*;\n\npublic class FutureExample {\n public static void main(String[] args) throws Exception {\n ExecutorService executor = Executors.newSingleThreadExecutor();\n\n Callable task = () -> {\n Thread.sleep(2000);\n return \"Task completed!\";\n };\n\n Future future = executor.submit(task);\n\n System.out.println(\"Doing other work...\");\n\n String result = future.get(); // Waits for task to complete and gets result\n System.out.println(result);\n\n executor.shutdown();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","text":"A "},{"type":"text","marks":[{"type":"code"}],"text":"Future"},{"type":"text","text":" in Java represents the result of an asynchronous computation. When you submit a task to an "},{"type":"text","marks":[{"type":"code"}],"text":"ExecutorService"},{"type":"text","text":", it returns a "},{"type":"text","marks":[{"type":"code"}],"text":"Future"},{"type":"text","text":" object, which acts like a placeholder for the result. You can use "},{"type":"text","marks":[{"type":"code"}],"text":"future.get()"},{"type":"text","text":" to block and retrieve the result once the task is complete. It also provides methods to check if the task is done or to cancel it. This is useful for managing long-running tasks without blocking the main thread immediately. In this example, while the background task runs, the main thread can continue doing other work and later use "},{"type":"text","marks":[{"type":"code"}],"text":"future.get()"},{"type":"text","text":" to retrieve the result."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"6. What is a thread pool, and how does ThreadPoolExecutor work in Java? Explain the significance of parameters like core pool size, maximum pool size, and keep-alive time."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Pool"},{"type":"text","text":": A collection of reusable threads that execute tasks, reducing the overhead of thread creation and improving resource utilization."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"ThreadPoolExecutor"},{"type":"text","text":": A flexible implementation of ExecutorService that manages a thread pool with configurable parameters."}]}]}]},{"type":"paragraph","content":[{"type":"text","text":"We need a "},{"type":"text","marks":[{"type":"bold"}],"text":"thread pool"},{"type":"text","text":" when we want to efficiently manage and execute a large number of concurrent tasks without overwhelming the system with excessive thread creation. Creating a new thread for each task is expensive in terms of memory and CPU, and can lead to performance bottlenecks or even system crashes under high load. A thread pool solves this by reusing a fixed number of threads to execute multiple tasks. This approach reduces overhead, provides better control over concurrency, and improves the application’s scalability and responsiveness."}]},{"type":"paragraph","content":[{"type":"text","text":"The "},{"type":"text","marks":[{"type":"code"}],"text":"ThreadPoolExecutor"},{"type":"text","text":" is the most flexible and powerful implementation of a thread pool in Java. It allows fine-grained control over key parameters like the number of core threads, maximum threads, task queue capacity, thread idle time, and rejection policy. You use "},{"type":"text","marks":[{"type":"code"}],"text":"ThreadPoolExecutor"},{"type":"text","text":" when you need custom behavior, such as tuning performance under specific workloads, handling bursts of tasks, or implementing advanced concurrency policies. Unlike factory methods like "},{"type":"text","marks":[{"type":"code"}],"text":"Executors.newFixedThreadPool()"},{"type":"text","text":", "},{"type":"text","marks":[{"type":"code"}],"text":"ThreadPoolExecutor"},{"type":"text","text":" gives you direct control over thread lifecycle and task management, making it ideal for enterprise-grade applications where resource management and throughput are critical."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"How It Works"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Tasks are submitted to a queue (e.g., LinkedBlockingQueue)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Threads from the pool execute tasks. If all threads are busy and the queue is full, new threads are created (up to maximumPoolSize)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Idle threads beyond corePoolSize are terminated after keepAliveTime."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Key Parameters"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Core Pool Size"},{"type":"text","text":": Minimum number of threads kept alive, even when idle."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Maximum Pool Size"},{"type":"text","text":": Maximum number of threads allowed when the queue is full."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Keep-Alive Time"},{"type":"text","text":": Time idle threads (beyond core size) are kept before termination."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Work Queue"},{"type":"text","text":": Holds tasks when all threads are busy (e.g., bounded or unbounded queues)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Factory"},{"type":"text","text":": Customizes thread creation (e.g., naming)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Rejected Execution Handler"},{"type":"text","text":": Defines behavior when tasks are rejected (e.g., queue full and max threads reached)."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.*;\n\npublic class ThreadPoolExecutorExample {\n public static void main(String[] args) {\n ThreadPoolExecutor executor = new ThreadPoolExecutor(\n 2, // corePoolSize\n 4, // maximumPoolSize\n 60, TimeUnit.SECONDS, // keepAliveTime\n new LinkedBlockingQueue<>(2), // workQueue\n Executors.defaultThreadFactory(),\n new ThreadPoolExecutor.AbortPolicy()\n );\n\n for (int i = 1; i <= 6; i++) {\n final int taskId = i;\n executor.execute(() -> {\n System.out.println(\"Task \" + taskId + \" executed by \" + Thread.currentThread().getName());\n try {\n Thread.sleep(1000);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n });\n }\n executor.shutdown();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","text":"Explanation: Configures a thread pool with 2 core threads, up to 4 total, and a queue of size 2. Excess tasks trigger the AbortPolicy if the queue and max threads are full."}]},{"type":"paragraph","content":[{"type":"text","text":"The business logic block simulates a task by printing which thread is executing which task, and then sleeping for 1 second to mimic some processing time. In real-world scenarios, this is where you would place logic like file processing, database operations, or network calls."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"7. What is the difference between Callable and Runnable interfaces? How does the Future interface complement Callable in concurrent programming?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Differences"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Return Value"},{"type":"text","text":": Runnable’s run() method returns void; Callable’s call() method returns a value (generic type) and can throw checked exceptions."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Purpose"},{"type":"text","text":": Runnable is for tasks with no result (e.g., logging); Callable is for tasks that produce results (e.g., computations)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Execution"},{"type":"text","text":": Runnable is used with Thread or Executor; Callable is typically used with ExecutorService."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Future Complementing Callable"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Future represents the result of an asynchronous computation submitted via ExecutorService.submit(Callable)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"It allows retrieving the result (get()), checking completion (isDone()), or canceling the task (cancel())."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Handles exceptions thrown by Callable."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.*;\n\npublic class CallableFutureExample {\n public static void main(String[] args) throws Exception {\n ExecutorService executor = Executors.newSingleThreadExecutor();\n Callable task = () -> {\n Thread.sleep(1000);\n return 42;\n };\n Future future = executor.submit(task);\n System.out.println(\"Task submitted. Waiting for result...\");\n Integer result = future.get(); // Blocks until result is ready\n System.out.println(\"Result: \" + result);\n executor.shutdown();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": Callable computes a result, and Future retrieves it asynchronously."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"8. Describe the ForkJoinPool framework. How does it implement work-stealing, and what types of problems is it best suited for?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"ForkJoinPool"},{"type":"text","text":": A specialized ExecutorService for divide-and-conquer tasks, introduced in Java 7. It’s designed for recursive, parallelizable problems."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Work-Stealing"},{"type":"text","text":": Each thread has a double-ended queue (deque) of tasks. If a thread’s queue is empty, it “steals” tasks from another thread’s deque (from the tail), balancing workload."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Mechanism"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Tasks (subclasses of ForkJoinTask, e.g., RecursiveTask or RecursiveAction) split into smaller subtasks using fork()."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Subtasks are executed in parallel, and results are combined using join()."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Best Suited For"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Recursive algorithms (e.g., merge sort, quicksort, tree traversals)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"CPU-bound tasks with minimal I/O."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Tasks that can be broken into independent subtasks."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.*;\n\npublic class ForkJoinSum extends RecursiveTask {\n private final int[] numbers;\n private final int start, end;\n private static final int THRESHOLD = 10;\n\n public ForkJoinSum(int[] numbers, int start, int end) {\n this.numbers = numbers;\n this.start = start;\n this.end = end;\n }\n\n @Override\n protected Long compute() {\n if (end - start <= THRESHOLD) {\n long sum = 0;\n for (int i = start; i < end; i++) {\n sum += numbers[i];\n }\n return sum;\n } else {\n int mid = start + (end - start) / 2;\n ForkJoinSum left = new ForkJoinSum(numbers, start, mid);\n ForkJoinSum right = new ForkJoinSum(numbers, mid, end);\n left.fork(); // Execute left task asynchronously\n long rightResult = right.compute(); // Compute right task\n long leftResult = left.join(); // Wait for left task\n return leftResult + rightResult;\n }\n }\n\n public static void main(String[] args) {\n int[] numbers = new int[100];\n for (int i = 0; i < numbers.length; i++) numbers[i] = i + 1;\n ForkJoinPool pool = ForkJoinPool.commonPool();\n long sum = pool.invoke(new ForkJoinSum(numbers, 0, numbers.length));\n System.out.println(\"Sum: \" + sum); // Expected: 5050\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": Computes the sum of an array by recursively splitting tasks, leveraging work-stealing for efficiency."}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"9. What is a deadlock in Java? Explain how it occurs, how to detect it, and strategies to prevent it in a multithreaded application."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Deadlock"},{"type":"text","text":": A situation where two or more threads are blocked forever, each waiting for a resource held by another."}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"How It Occurs"},{"type":"text","text":": Requires four conditions (Coffman conditions):"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Mutual Exclusion"},{"type":"text","text":": Resources (e.g., locks) are held exclusively."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Hold and Wait"},{"type":"text","text":": Threads hold at least one resource and wait for others."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"No Preemption"},{"type":"text","text":": Resources cannot be forcibly released."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Circular Wait"},{"type":"text","text":": Threads form a circular dependency (e.g., T1 waits for T2’s resource, T2 waits for T1’s)."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Detection"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Tools"},{"type":"text","text":": Use jstack or ThreadMXBean to dump thread states and identify lock dependencies."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"VisualVM/JConsole"},{"type":"text","text":": Monitor threads for blocked states."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Prevention"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Lock Ordering"},{"type":"text","text":": Always acquire locks in a consistent order."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Timeouts"},{"type":"text","text":": Use tryLock() with ReentrantLock to avoid indefinite waiting."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Avoid Nested Locks"},{"type":"text","text":": Minimize locking multiple resources simultaneously."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Use Higher-Level Concurrency"},{"type":"text","text":": Prefer ConcurrentHashMap or BlockingQueue over raw locks."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"public class DeadlockExample {\n public static void main(String[] args) {\n String resource1 = \"Resource1\";\n String resource2 = \"Resource2\";\n\n Thread t1 = new Thread(() -> {\n synchronized (resource1) {\n System.out.println(\"T1 locked resource1\");\n try { Thread.sleep(100); } catch (Exception e) {}\n synchronized (resource2) {\n System.out.println(\"T1 locked resource2\");\n }\n }\n });\n\n Thread t2 = new Thread(() -> {\n synchronized (resource2) {\n System.out.println(\"T2 locked resource2\");\n try { Thread.sleep(100); } catch (Exception e) {}\n synchronized (resource1) {\n System.out.println(\"T2 locked resource1\");\n }\n }\n });\n\n t1.start();\n t2.start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": T1 locks resource1 and waits for resource2; T2 locks resource2 and waits for resource1, causing a deadlock."}]},{"type":"heading","attrs":{"level":3},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"10. Explain the concept of livelock. How does it differ from deadlock, and how can you mitigate it in a Java application?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"heading","attrs":{"level":2},"content":[{"type":"text","text":"Get Rahul Krishnan’s stories in your inbox"}]},{"type":"paragraph","content":[{"type":"text","text":"Join Medium for free to get updates from this writer."}]},{"type":"paragraph","content":[{"type":"text","text":"Subscribe"}]},{"type":"paragraph","content":[{"type":"text","text":"Remember me for faster sign in"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Livelock"},{"type":"text","text":": Threads are active but unable to progress because they keep responding to each other’s actions (e.g., two people stepping aside to avoid collision, repeatedly). Unlike deadlock, threads are not blocked but stuck in a loop of state changes."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Difference from Deadlock"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Deadlock"},{"type":"text","text":": Threads are blocked, waiting for resources."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Livelock"},{"type":"text","text":": Threads are running but cannot complete due to cyclic reactions."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Mitigation"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Randomization"},{"type":"text","text":": Introduce random delays or choices to break cyclic behavior."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Priority or Ordering"},{"type":"text","text":": Assign priorities to threads or enforce a consistent action order."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Timeouts"},{"type":"text","text":": Limit retry attempts to exit livelock scenarios."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.Random;\n\npublic class LivelockExample {\n static class Person {\n private String name;\n private boolean movedAside = false;\n private Random random = new Random();\n\n Person(String name) {\n this.name = name;\n }\n\n public boolean moveAside(Person other) {\n if (other.movedAside) {\n System.out.println(name + \" passes as \" + other.name + \" moved aside\");\n return true; // Can pass\n }\n System.out.println(name + \" moves aside\");\n movedAside = true;\n try { Thread.sleep(random.nextInt(100)); } catch (Exception e) {}\n return false;\n }\n }\n\n public static void main(String[] args) {\n Person alice = new Person(\"Alice\");\n Person bob = new Person(\"Bob\");\n\n Thread t1 = new Thread(() -> {\n while (!alice.moveAside(bob)) {\n alice.movedAside = false; // Reset and retry\n try { Thread.sleep(100); } catch (Exception e) {}\n }\n });\n\n Thread t2 = new Thread(() -> {\n while (!bob.moveAside(alice)) {\n bob.movedAside = false; // Reset and retry\n try { Thread.sleep(100); } catch (Exception e) {}\n }\n });\n\n t1.start();\n t2.start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": Alice and Bob keep moving aside for each other, potentially causing livelock. Random delays help mitigate it by breaking symmetry."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"11. What is the ConcurrentHashMap class? How does it achieve thread safety without locking the entire map, and how does it differ from Hashtable?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"ConcurrentHashMap"},{"type":"text","text":": A thread-safe implementation of Map in java.util.concurrent, designed for high-concurrency environments."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Safety Mechanism"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Segmented Locking (Java 7)"},{"type":"text","text":": Divides the map into segments, locking only the segment being modified."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Lock Striping (Java 8+)"},{"type":"text","text":": Uses fine-grained locks on buckets, allowing concurrent reads and writes to different buckets."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"CAS Operations"},{"type":"text","text":": Uses compare-and-swap for atomic updates (e.g., putIfAbsent)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"No Full Locking"},{"type":"text","text":": Unlike Hashtable, it doesn’t lock the entire map, improving scalability."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Differences from Hashtable"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Locking"},{"type":"text","text":": Hashtable locks the entire map for every operation; ConcurrentHashMap uses finer-grained locking."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Null Handling"},{"type":"text","text":": Hashtable allows null keys/values; ConcurrentHashMap does not."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Performance"},{"type":"text","text":": ConcurrentHashMap is faster in high-concurrency scenarios."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Iteration"},{"type":"text","text":": ConcurrentHashMap supports weakly consistent iterators, tolerating concurrent modifications."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.ConcurrentHashMap;\n\npublic class ConcurrentHashMapExample {\n public static void main(String[] args) {\n ConcurrentHashMap map = new ConcurrentHashMap<>();\n Runnable task = () -> {\n for (int i = 0; i < 100; i++) {\n map.compute(\"key\", (k, v) -> v == null ? 1 : v + 1);\n }\n };\n Thread t1 = new Thread(task);\n Thread t2 = new Thread(task);\n t1.start();\n t2.start();\n try {\n t1.join();\n t2.join();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n System.out.println(\"Final count: \" + map.get(\"key\")); // Expected: 200\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": ConcurrentHashMap safely handles concurrent updates to the same key using atomic operations."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"12. What are the benefits of using CopyOnWriteArrayList? In what scenarios is it appropriate, and what are its performance implications?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"CopyOnWriteArrayList"},{"type":"text","text":": A thread-safe List implementation where modifications create a new copy of the underlying array."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Benefits"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Safety"},{"type":"text","text":": No explicit synchronization needed; reads are lock-free."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Iterator Safety"},{"type":"text","text":": Iterators reflect the list’s state at creation, unaffected by concurrent modifications."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Simplicity"},{"type":"text","text":": Ideal for scenarios with frequent reads and rare writes."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Appropriate Scenarios"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Event listeners or observers lists (e.g., in GUI frameworks)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Caching immutable data with occasional updates."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Read-heavy applications where consistency during iteration is critical."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Performance Implications"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Pros"},{"type":"text","text":": Fast reads (no locking)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Cons"},{"type":"text","text":": Slow writes (copying the array is expensive, O(n)). High memory usage due to multiple copies during updates."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.List;\nimport java.util.concurrent.CopyOnWriteArrayList;\n\npublic class CopyOnWriteArrayListExample {\n public static void main(String[] args) {\n List list = new CopyOnWriteArrayList<>();\n list.add(\"A\");\n list.add(\"B\");\n\n Thread writer = new Thread(() -> {\n try {\n Thread.sleep(100);\n list.add(\"C\");\n System.out.println(\"Added C\");\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n });\n\n Thread reader = new Thread(() -> {\n for (String item : list) {\n System.out.println(\"Read: \" + item);\n try {\n Thread.sleep(200);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n });\n\n writer.start();\n reader.start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": The reader’s iterator sees only “A” and “B” despite the writer adding “C”, showcasing iterator safety."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"13. Explain the role of CountDownLatch in Java. Provide a real-world example where it would be useful in coordinating threads."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"CountDownLatch"},{"type":"text","text":": A synchronization aid that allows one or more threads to wait until a set of operations in other threads completes. It maintains a count, decremented by countDown(). Threads calling await() block until the count reaches zero."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Role"},{"type":"text","text":": Coordinates threads by ensuring a task waits for dependencies to complete."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Real-World Example"},{"type":"text","text":": Initializing an application where multiple services (e.g., database, cache) must start before processing requests."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.CountDownLatch;\n\npublic class CountDownLatchExample {\n public static void main(String[] args) throws InterruptedException {\n CountDownLatch latch = new CountDownLatch(3);\n\n Runnable service = () -> {\n try {\n System.out.println(Thread.currentThread().getName() + \" starting...\");\n Thread.sleep(1000);\n System.out.println(Thread.currentThread().getName() + \" completed.\");\n latch.countDown();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n };\n\n new Thread(service, \"Database\").start();\n new Thread(service, \"Cache\").start();\n new Thread(service, \"Logger\").start();\n\n System.out.println(\"Waiting for services...\");\n latch.await();\n System.out.println(\"All services up. Starting application.\");\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": The main thread waits for three services to complete using CountDownLatch."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"14. What is a CyclicBarrier, and how does it differ from CountDownLatch? Provide a use case where CyclicBarrier is more appropriate."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"CyclicBarrier"},{"type":"text","text":": A synchronization aid where a fixed number of threads wait at a barrier until all arrive, then proceed together. It can be reused (cyclic) and supports an optional Runnable action when the barrier is tripped."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Differences from CountDownLatch"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Purpose"},{"type":"text","text":": CountDownLatch is for one thread waiting for others to complete; CyclicBarrier is for mutual synchronization among threads."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Reuse"},{"type":"text","text":": CyclicBarrier can be reset and reused; CountDownLatch is one-time."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Participants"},{"type":"text","text":": CyclicBarrier requires all threads to call await(); CountDownLatch allows separate decrementers and waiters."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Use Case"},{"type":"text","text":": Parallel computations where threads must complete a phase (e.g., matrix multiplication) before proceeding to the next."}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.CyclicBarrier;\n\npublic class CyclicBarrierExample {\n public static void main(String[] args) {\n CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println(\"All tasks completed phase.\"));\n\n Runnable task = () -> {\n try {\n System.out.println(Thread.currentThread().getName() + \" workingmeasuringPoint() working...\");\n barrier.await();\n System.out.println(Thread.currentThread().getName() + \" reached barrier.\");\n } catch (Exception e) {\n Thread.currentThread().interrupt();\n }\n };\n\n Thread t1 = new Thread(task, \"Worker1\");\n Thread t2 = new Thread(task, \"Worker2\");\n Thread t3 = new Thread(task, \"Worker3\");\n\n t1.start();\n t2.start();\n t3.start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": Three threads wait at the barrier, simulating a phase of work. Once all reach await(), the barrier action runs, and threads proceed."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"15. What is the Semaphore class in Java? Explain how it can be used to control access to a shared resource, and provide an example."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Semaphore"},{"type":"text","text":": A synchronization tool that maintains a set of permits. Threads acquire permits (acquire()) to access a resource and release them (release()). If no permits are available, threads block."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Use Case"},{"type":"text","text":": Limiting concurrent access to a resource (e.g., database connections, thread pool slots)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Mechanism"},{"type":"text","text":": Unlike locks, semaphores allow multiple threads (up to the permit count) to access the resource simultaneously."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.Semaphore;\n\npublic class SemaphoreExample {\n static class ResourcePool {\n private final Semaphore semaphore = new Semaphore(2); // 2 permits\n\n public void accessResource() {\n try {\n semaphore.acquire();\n System.out.println(Thread.currentThread().getName() + \" accessing resource\");\n Thread.sleep(1000);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n } finally {\n System.out.println(Thread.currentThread().getName() + \" releasing resource\");\n semaphore.release();\n }\n }\n }\n\n public static void main(String[] args) {\n ResourcePool pool = new ResourcePool();\n Runnable task = () -> pool.accessResource();\n for (int i = 1; i <= 5; i++) {\n new Thread(task, \"Thread-\" + i).start();\n }\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": Only 2 threads can access the resource at a time, controlled by the semaphore’s permits."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"16. Describe the BlockingQueue interface and its implementations (e.g., ArrayBlockingQueue, LinkedBlockingQueue). How are they used in producer-consumer patterns?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"BlockingQueue"},{"type":"text","text":": A queue interface (java.util.concurrent) that supports blocking operations for adding (put()) and removing (take()) elements when the queue is full or empty."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Implementations"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"ArrayBlockingQueue"},{"type":"text","text":": Bounded queue backed by an array, with fixed capacity."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"LinkedBlockingQueue"},{"type":"text","text":": Optionally bounded queue backed by linked nodes, more flexible for large queues."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"SynchronousQueue"},{"type":"text","text":": No capacity; each put waits for a take and vice versa."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Producer-Consumer Pattern"},{"type":"text","text":": Producers add items to the queue; consumers remove them. BlockingQueue handles synchronization and blocking, simplifying coordination."}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.*;\n\npublic class ProducerConsumer {\n public static void main(String[] args) {\n BlockingQueue queue = new ArrayBlockingQueue<>(10);\n\n Runnable producer = () -> {\n try {\n for (int i = 1; i <= 5; i++) {\n queue.put(i);\n System.out.println(\"Produced: \" + i);\n Thread.sleep(100);\n }\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n };\n\n Runnable consumer = () -> {\n try {\n for (int i = 1; i <= 5; i++) {\n int item = queue.take();\n System.out.println(\"Consumed: \" + item);\n Thread.sleep(200);\n }\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n };\n\n new Thread(producer).start();\n new Thread(consumer).start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": The producer adds items to the queue, and the consumer removes them, with BlockingQueue handling synchronization."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"17. What is the ThreadLocal class, and how does it work? Provide an example where ThreadLocal is useful in a multithreaded application."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"ThreadLocal"},{"type":"text","text":": A class that provides thread-local storage, where each thread has its own copy of a variable. Accessed via get(), set(), and remove()."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"How It Works"},{"type":"text","text":": Internally, ThreadLocal maintains a map (per thread) associating threads with their variable instances. It ensures thread isolation, avoiding synchronization."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Use Case"},{"type":"text","text":": Storing per-thread context (e.g., user sessions, transaction IDs)."}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"public class ThreadLocalExample {\n private static final ThreadLocal userContext = new ThreadLocal<>();\n\n public static void main(String[] args) {\n Runnable task = () -> {\n userContext.set(Thread.currentThread().getName() + \"-User\");\n System.out.println(Thread.currentThread().getName() + \" context: \" + userContext.get());\n userContext.remove(); // Clean up\n };\n\n Thread t1 = new Thread(task, \"User1\");\n Thread t2 = new Thread(task, \"User2\");\n t1.start();\n t2.start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": Each thread maintains its own user context, isolated from others."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"18. Explain the concept of starvation in multithreading. How can it occur in Java, and what techniques can be used to prevent it?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Starvation"},{"type":"text","text":": A thread is unable to access a resource because other threads continuously acquire it, often due to unfair scheduling or lock contention."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"How It Occurs"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Unfair Locks"},{"type":"text","text":": Non-fair locks (e.g., default ReentrantLock) may favor threads already holding locks."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Priority Issues"},{"type":"text","text":": Low-priority threads may be preempted by high-priority ones."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Busy Resources"},{"type":"text","text":": Threads monopolizing shared resources (e.g., CPU, locks)."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Prevention"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Fair Locks"},{"type":"text","text":": Use ReentrantLock(true) for FIFO ordering."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Priorities"},{"type":"text","text":": Avoid extreme priority differences."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Resource Limits"},{"type":"text","text":": Use semaphores or thread pools to limit resource hogging."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Randomization"},{"type":"text","text":": Introduce randomness in scheduling to avoid consistent favoring."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.locks.ReentrantLock;\n\npublic class StarvationExample {\n private static final ReentrantLock lock = new ReentrantLock(); // Non-fair by default\n\n public static void main(String[] args) {\n Runnable task = () -> {\n while (true) {\n if (lock.tryLock()) {\n try {\n System.out.println(Thread.currentThread().getName() + \" acquired lock\");\n Thread.sleep(100);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n } finally {\n lock.unlock();\n }\n }\n }\n };\n\n for (int i = 1; i <= 3; i++) {\n Thread t = new Thread(task, \"Thread-\" + i);\n t.setPriority(i * 2); // Varying priorities\n t.start();\n }\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": High-priority threads may dominate lock acquisition, starving lower-priority ones. Using ReentrantLock(true) mitigates this."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"19. What is the purpose of the Lock interface in the java.util.concurrent.locks package? How does it provide more flexibility compared to synchronized blocks?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Lock Interface"},{"type":"text","text":": Provides explicit locking mechanisms (e.g., lock(), unlock()) for mutual exclusion, part of java.util.concurrent.locks."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Purpose"},{"type":"text","text":": Offers a programmatic alternative to synchronized, with advanced features."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Flexibility vs. synchronized"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Try-Lock"},{"type":"text","text":": tryLock() allows non-blocking or timed lock attempts."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Interruptibility"},{"type":"text","text":": lockInterruptibly() allows interruption during lock acquisition."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Fairness"},{"type":"text","text":": Supports fair locking (FIFO) via ReentrantLock(true)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Conditions"},{"type":"text","text":": Supports multiple Condition objects for fine-grained coordination."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Non-Block Scope"},{"type":"text","text":": Locks can be acquired/released across methods, unlike synchronized’s block/method scope."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.locks.*;\n\npublic class LockExample {\n private final Lock lock = new ReentrantLock(true); // Fair lock\n private int count = 0;\n\n public void increment() {\n if (lock.tryLock()) {\n try {\n count++;\n } finally {\n lock.unlock();\n }\n }\n }\n\n public int getCount() {\n lock.lock();\n try {\n return count;\n } finally {\n lock.unlock();\n }\n }\n\n public static void main(String[] args) throws InterruptedException {\n LockExample example = new LockExample();\n Runnable task = () -> {\n for (int i = 0; i < 1000; i++) {\n example.increment();\n }\n };\n Thread t1 = new Thread(task);\n Thread t2 = new Thread(task);\n t1.start();\n t2.start();\n t1.join();\n t2.join();\n System.out.println(\"Final count: \" + example.getCount());\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": tryLock() allows non-blocking attempts, showcasing Lock’s flexibility."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"20. Describe how the CompletableFuture class works in Java. How does it support asynchronous programming, and what are some common use cases?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"CompletableFuture"},{"type":"text","text":": A Future implementation that supports asynchronous computations with callbacks, chaining, and composition, introduced in Java 8."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"How It Works"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Represents a computation that may complete later."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Supports methods like supplyAsync(), thenApply(), thenCombine(), and handle() for chaining operations."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Can be manually completed (complete()) or exceptionally completed (completeExceptionally())."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Asynchronous Support"},{"type":"text","text":": Runs tasks in a thread pool (default: ForkJoinPool.commonPool()) and allows non-blocking result handling."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Use Cases"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Asynchronous API calls (e.g., fetching data from multiple services)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Parallel processing of independent tasks."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Error handling in asynchronous workflows."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.*;\n\npublic class CompletableFutureExample {\n public static void main(String[] args) throws Exception {\n CompletableFuture future = CompletableFuture.supplyAsync(() -> {\n try {\n Thread.sleep(1000);\n return \"Hello\";\n } catch (InterruptedException e) {\n throw new RuntimeException(e);\n }\n }).thenApply(s -> s + \", World!\");\n\n System.out.println(future.get()); // Blocks until complete\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": supplyAsync runs a task asynchronously, and thenApply transforms the result."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"21. What are the challenges of using immutable objects in a multithreaded environment? How does immutability help in achieving thread safety?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Immutability"},{"type":"text","text":": An object whose state cannot change after creation."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Thread Safety"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"No Modification"},{"type":"text","text":": Immutable objects cannot be altered, eliminating race conditions."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Safe Sharing"},{"type":"text","text":": Can be shared across threads without synchronization."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Predictability"},{"type":"text","text":": Consistent state simplifies reasoning in concurrent code."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Challenges"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Memory Overhead"},{"type":"text","text":": Creating new objects for each change can be costly."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Performance"},{"type":"text","text":": Copying large objects (e.g., collections) is expensive."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Design Complexity"},{"type":"text","text":": Requires careful design to ensure true immutability (e.g., defensive copying of mutable fields)."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"public final class ImmutablePoint {\n private final int x;\n private final int y;\n\n public ImmutablePoint(int x, int y) {\n this.x = x;\n this.y = y;\n }\n\n public int getX() { return x; }\n public int getY() { return y; }\n\n public ImmutablePoint move(int dx, int dy) {\n return new ImmutablePoint(x + dx, y + dy); // New instance\n }\n}\n\nclass ImmutableExample {\n public static void main(String[] args) {\n ImmutablePoint point = new ImmutablePoint(1, 2);\n Runnable task = () -> System.out.println(Thread.currentThread().getName() + \": \" + point.getX() + \",\" + point.getY());\n “‘System: * Today's date and time is 02:11 PM AEST on Monday, May 19, 2025."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"22. Explain the concept of atomic operations in Java. How do classes like AtomicInteger and AtomicReference ensure thread-safe operations without locks?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Atomic Operations"},{"type":"text","text":": Operations that execute as a single, indivisible unit, ensuring thread safety without race conditions. They guarantee that intermediate states are not visible to other threads."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Classes like AtomicInteger and AtomicReference"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Part of the java.util.concurrent.atomic package, these classes provide lock-free, thread-safe operations using "},{"type":"text","marks":[{"type":"bold"}],"text":"Compare-and-Swap (CAS)"},{"type":"text","text":"."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"CAS Mechanism"},{"type":"text","text":": CAS is a hardware-supported operation that atomically compares a variable’s current value to an expected value and updates it to a new value if they match. If not, it retries (optimistic concurrency)."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"How It Works"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"AtomicInteger supports operations like incrementAndGet(), compareAndSet(), and getAndAdd()."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"AtomicReference allows atomic updates to object references."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Uses low-level CPU instructions (e.g., cmpxchg) via sun.misc.Unsafe or VarHandle (Java 9+)."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Advantages"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Lock-free, reducing contention and deadlock risks."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"High performance in low-to-moderate contention scenarios."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Limitations"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"CAS can suffer from the ABA problem (solved using AtomicStampedReference)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"High contention may lead to repeated retries, reducing efficiency."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.atomic.AtomicInteger;\n\npublic class AtomicIntegerExample {\n private static final AtomicInteger counter = new AtomicInteger(0);\n\n public static void main(String[] args) throws InterruptedException {\n Runnable task = () -> {\n for (int i = 0; i < 1000; i++) {\n counter.incrementAndGet();\n }\n };\n\n Thread t1 = new Thread(task);\n Thread t2 = new Thread(task);\n t1.start();\n t2.start();\n t1.join();\n t2.join();\n System.out.println(\"Final count: \" + counter.get()); // Expected: 2000\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": AtomicInteger ensures thread-safe increments using CAS, avoiding the need for explicit locks. The incrementAndGet() method atomically increments the value and returns the updated value."}]},{"type":"heading","attrs":{"level":2},"content":[{"type":"text","marks":[{"type":"bold"}],"text":"23. What is the double-checked locking pattern, and why is it problematic in Java? How can it be correctly implemented using volatile?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Double-Checked Locking (DCL)"},{"type":"text","text":": A pattern to lazily initialize a singleton in a thread-safe manner while minimizing synchronization overhead. It checks a condition twice: once without locking and once with locking."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Why It’s Problematic"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Pre-Java 5 Issue"},{"type":"text","text":": Without proper memory visibility guarantees (before Java Memory Model improvements), a partially constructed object could be visible to other threads due to instruction reordering. For example, a thread might see a non-null reference to a singleton before its fields are initialized."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Root Cause"},{"type":"text","text":": The JVM or CPU may reorder operations, making field initialization visible after the reference is set, leading to race conditions."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Correct Implementation with volatile"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Declaring the singleton field as volatile ensures that writes to the object are not reordered and are visible to all threads (happens-before guarantee)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"The pattern checks the instance twice: first to avoid synchronization if initialized, and second within a synchronized block to ensure safe initialization."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"public class DoubleCheckedLocking {\n private static volatile DoubleCheckedLocking instance;\n\n private DoubleCheckedLocking() {\n // Prevent instantiation\n }\n\n public static DoubleCheckedLocking getInstance() {\n if (instance == null) { // First check (no synchronization)\n synchronized (DoubleCheckedLocking.class) {\n if (instance == null) { // Second check (with synchronization)\n instance = new DoubleCheckedLocking();\n }\n }\n }\n return instance;\n }\n\n public static void main(String[] args) {\n Runnable task = () -> System.out.println(DoubleCheckedLocking.getInstance().hashCode());\n Thread t1 = new Thread(task);\n Thread t2 = new Thread(task);\n t1.start();\n t2.start();\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": The volatile keyword ensures that the instance initialization is not reordered, making DCL thread-safe. The first check avoids synchronization overhead, and the second check ensures only one instance is created."}]},{"type":"paragraph","content":[{"type":"text","text":"In Java, the "},{"type":"text","marks":[{"type":"code"}],"text":"volatile"},{"type":"text","text":" keyword is used to make sure that changes to a variable are always seen by all threads. Normally, each thread might keep its own copy of a variable for speed, but this can cause problems when different threads are trying to use or change the same variable. When a variable is marked "},{"type":"text","marks":[{"type":"code"}],"text":"volatile"},{"type":"text","text":", it tells Java not to use those private copies and to always read and write the value directly from main memory. This helps keep the data consistent between threads. However, "},{"type":"text","marks":[{"type":"code"}],"text":"volatile"},{"type":"text","text":" does not prevent multiple threads from changing the value at the same time—it just makes sure they see the latest value."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"24. How does the java.util.concurrent package support optimistic concurrency control? Provide an example using ConcurrentSkipListMap or ConcurrentLinkedQueue."}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Optimistic Concurrency Control"},{"type":"text","text":": A strategy where threads perform operations assuming no conflicts, checking for conflicts only when committing changes (e.g., using CAS instead of locks)."}]},{"type":"paragraph","content":[{"type":"text","text":"CAS, or Compare-And-Swap, is a way for Java to safely update a variable when many threads are using it. It works by checking if the variable has the value you expect, and if it does, it changes it to a new value. If someone else changed the variable first, the update won’t happen, and the thread can try again. This helps avoid using locks, which can slow things down. CAS is like saying, “If no one has touched this number, I’ll change it; otherwise, I’ll back off and try again.”"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Support in java.util.concurrent"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","text":"Classes like ConcurrentLinkedQueue and ConcurrentSkipListMap use lock-free algorithms (often CAS-based) to allow concurrent modifications without blocking."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"ConcurrentLinkedQueue"},{"type":"text","text":": A lock-free, unbounded queue using CAS for thread-safe insertions and removals."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"ConcurrentSkipListMap"},{"type":"text","text":": A scalable, concurrent sorted map using skip-list data structure, supporting lock-free operations for most methods."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Mechanism"},{"type":"text","text":": These classes rely on atomic operations to update internal data structures, retrying if conflicts occur, which reduces contention compared to lock-based approaches."}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"import java.util.concurrent.ConcurrentLinkedQueue;\n\npublic class ConcurrentLinkedQueueExample {\n public static void main(String[] args) throws InterruptedException {\n ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue<>();\n\n Runnable producer = () -> {\n for (int i = 1; i <= 100; i++) {\n queue.offer(i);\n System.out.println(Thread.currentThread().getName() + \" produced: \" + i);\n }\n };\n\n Runnable consumer = () -> {\n for (int i = 1; i <= 100; i++) {\n Integer value = queue.poll();\n if (value != null) {\n System.out.println(Thread.currentThread().getName() + \" consumed: \" + value);\n }\n }\n };\n\n Thread p1 = new Thread(producer, \"Producer1\");\n Thread p2 = new Thread(producer, \"Producer2\");\n Thread c1 = new Thread(consumer, \"Consumer1\");\n Thread c2 = new Thread(consumer, \"Consumer2\");\n\n p1.start();\n p2.start();\n c1.start();\n c2.start();\n\n p1.join();\n p2.join();\n c1.join();\n c2.join();\n\n System.out.println(\"Queue size: \" + queue.size());\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": ConcurrentLinkedQueue uses CAS to ensure thread-safe offer and poll operations, allowing multiple producers and consumers to operate concurrently without locks"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"},{"type":"italic"}],"text":"25. What are the risks of thread interruption in Java? How should you properly handle InterruptedException to ensure robust concurrent applications?"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Answer"},{"type":"text","text":":"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Risks of Thread Interruption"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Unexpected Termination"},{"type":"text","text":": Interrupting a thread can stop it abruptly, leaving resources in an inconsistent state (e.g., unclosed files, partial updates)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Missed Interrupts"},{"type":"text","text":": Failing to handle InterruptedException can cause threads to ignore cancellation requests, leading to resource leaks or hung threads."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"State Inconsistency"},{"type":"text","text":": If a thread is interrupted during a critical section, it may leave shared data corrupted."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Swallowed Interrupts"},{"type":"text","text":": Catching InterruptedException without restoring the interrupt status can prevent higher-level code from detecting the interruption."}]}]}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Proper Handling of InterruptedException"},{"type":"text","text":":"}]},{"type":"bulletList","attrs":{"tight":true},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Restore Interrupt Status"},{"type":"text","text":": If the thread cannot proceed, call Thread.currentThread().interrupt() to preserve the interrupt flag."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Clean Up Resources"},{"type":"text","text":": Ensure resources (e.g., locks, files) are released properly, typically in a finally block."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Propagate or Handle"},{"type":"text","text":": Either propagate the exception (if the method signature allows) or handle it appropriately (e.g., logging, graceful shutdown)."}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Avoid Swallowing"},{"type":"text","text":": Do not silently catch InterruptedException without action."}]}]}]},{"type":"codeBlock","attrs":{"language":null},"content":[{"type":"text","text":"public class InterruptHandlingExample {\n public static void main(String[] args) throws InterruptedException {\n Thread worker = new Thread(() -> {\n try {\n while (!Thread.currentThread().isInterrupted()) {\n System.out.println(\"Working...\");\n Thread.sleep(1000); // Simulates work\n }\n } catch (InterruptedException e) {\n // Restore interrupt status\n Thread.currentThread().interrupt();\n System.out.println(\"Thread interrupted, cleaning up...\");\n // Perform cleanup here\n }\n });\n\n worker.start();\n Thread.sleep(3000);\n worker.interrupt();\n worker.join();\n System.out.println(\"Worker terminated.\");\n }\n}"}]},{"type":"paragraph","content":[{"type":"text","marks":[{"type":"bold"}],"text":"Explanation"},{"type":"text","text":": The thread checks for interruption and handles InterruptedException by restoring the interrupt status, ensuring proper cleanup and termination."}]}]}

Stefan Colic

System design in hurry

First test blog