docs(executors): add deep dive on Executors.newCachedThreadPool()

WHAT was added:
- Comprehensive explanation of `Executors.newCachedThreadPool()`:
  • Dynamically resizable thread pool that creates new threads as needed.
  • Reuses idle threads (with 60s timeout) to reduce overhead.
  • No fixed size; can grow indefinitely based on workload.
  • Tasks are executed immediately (no queue by default).

- Two runnable Java examples:
  1. Basic demo showing thread creation for multiple tasks.
  2. Reuse demo showing how idle threads handle new tasks when spaced with delays.

- Comparison table:
  • Contrasted `newCachedThreadPool()` with `newFixedThreadPool(n)`.
  • Highlighted thread count, task handling, and idle timeout differences.

- Practical usage guidelines:
  ✔ Best for bursty workloads or unpredictable short-lived tasks.
  ✔ Avoid for long-running tasks (risk of unbounded thread growth).

- Pitfalls section:
  • Risk of unbounded thread creation → may exhaust system resources.
  • Thread starvation if tasks run too long.
  • Recommendations to prefer `newFixedThreadPool()` or `ThreadPoolExecutor` with limits for controlled scenarios.

- Custom alternative:
  • Provided example using `ThreadPoolExecutor` with `SynchronousQueue`.
  • Demonstrated limiting max pool size while retaining cached behavior.

WHY this matters:
- `newCachedThreadPool()` is a commonly misunderstood executor type.
- Developers often misuse it for long-running tasks, leading to performance issues.
- This doc + examples clarify correct use cases, trade-offs, and safer alternatives.

HINTS / NEXT STEPS:
- Always call `shutdown()` or `awaitTermination()` after task submission.
- Use `newCachedThreadPool()` for short tasks in highly concurrent, bursty environments (e.g., request handling).
- For fine-grained control → configure `ThreadPoolExecutor` manually.

KEYWORDS:
executors threadpool newCachedThreadPool concurrency java concurrency utilities synchronousqueue threadreuse.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section19MultiThreading/ThreadPooling/src/ExecutorsFramework/Understanding `Executors.newCachedThreadPool().txt renamed to Section19MultiThreading/ThreadPooling/ExecutorsFramework/src/TXTFiles/Understanding `Executors.newCachedThreadPool().txt

@@ -1,9 +1,10 @@
-Understanding Executors.newCachedThreadPool() in Java
+Understanding Executors.newCachedThreadPool() in Java:
 
-The newCachedThreadPool() method of the Executors class creates a dynamically resizable thread pool. It creates new
-threads as needed and reuses idle threads to optimize performance.
+The newCachedThreadPool() method of the Executors class creates a dynamically resizable thread pool.
 
-1️⃣ Key Features of newCachedThreadPool()
+It creates new threads as needed and reuses idle threads to optimize performance.
+
+1️⃣ Key Features of newCachedThreadPool():
 
 | Feature                 | Description                                                     |
 |-------------------------|-----------------------------------------------------------------|
@@ -136,13 +137,13 @@ public class CustomThreadPoolExample {
     }
 }
 
-✅ Advantage:
+Advantage:
 - Limits max threads to 10 (prevents excessive thread creation).
 - Uses SynchronousQueue, meaning tasks are directly handed off to threads (similar to newCachedThreadPool()).
 
-📌 Summary
+Summary:
 ✔ newCachedThreadPool() is great for handling short-lived, high-concurrency tasks.
 ✔ Automatically grows/shrinks based on workload demand.
 ✔ Idle threads terminate after 60 seconds.
 ✔ Be cautious of excessive thread creation for long-running tasks.
-✔ For more control, use ThreadPoolExecutor.
+✔ For more control, use ThreadPoolExecutor.