docs: add explanation of newFixedThreadPool vs newCachedThreadPool

WHAT was added:
- Java class demonstrating creation of thread pools using Executors factory methods.
- Detailed inline documentation (in English + Hindi) for:
  - Executors.newFixedThreadPool(int nThreads)
    → Creates a pool with fixed number of threads, queues extra tasks.
    → Best for controlled parallelism or resource-limited scenarios.
  - Executors.newCachedThreadPool()
    → Creates a pool that dynamically grows/shrinks based on demand.
    → Best for many short-lived or bursty tasks.

WHY this matters:
- Thread pool choice impacts application performance, scalability, and resource usage.
- Developers often misuse thread pools; documentation clarifies when to use fixed vs cached.
- Helps understand how Executors factory methods map to real-world concurrency needs.

HOW it works:
1. Executors.newFixedThreadPool(2):
   - Creates a pool of 2 threads.
   - If >2 tasks are submitted, extras wait in an unbounded queue.
   - Prevents uncontrolled thread creation but may increase latency under load.
2. Executors.newCachedThreadPool():
   - Starts with 0 threads, creates new threads as tasks arrive.
   - Reuses idle threads if available; threads idle for 60s are terminated.
   - May create unlimited threads, which can overwhelm system if workload spikes.

USE CASES:
- FixedThreadPool:
  - Database connections, CPU-bound processing, or predictable parallelism.
- CachedThreadPool:
  - Network request handling, RPC, microservice endpoints, or highly variable loads.

GOTCHAS:
- CachedThreadPool can exhaust system resources if tasks flood in faster than they complete.
- FixedThreadPool can cause long queues and increased latency under heavy load.
- Always shut down thread pools explicitly to avoid memory leaks.

KEYWORDS:
executors fixedthreadpool cachedthreadpool threadpool concurrency.

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

Author: Someshdiwan

Section19MultiThreading/ThreadPooling/ExecutorsFramework/ScheduledExecutorsServices/src/Main2.java

@@ -0,0 +1,39 @@
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class Main2 {
+    public static void main(String[] args) {
+        /*
+         * newFixedThreadPool(int nThreads):
+         * ---------------------------------
+         * - Creates a thread pool with a fixed number of threads.
+         * - If all threads are busy, new tasks wait in a queue until a thread becomes free.
+         * - Suitable when the number of threads should be constant,
+         *   e.g., controlling parallelism or limiting resource usage.
+
+         *   Ek fixed size ka thread pool banata hai.
+         *   Agar saare threads busy ho jayein, to naye tasks queue mein wait karte hain
+         *   jab tak koi thread free na ho jaye.
+         *   Isko tab use karo jab threads ki count constant rakhni ho,
+         *   jaise limited parallelism ya resource control ke liye.
+         */
+        Executors.newFixedThreadPool(2);
+
+        /*
+         * newCachedThreadPool():
+         * ----------------------
+         * - Creates a thread pool that dynamically adjusts the number of threads
+         *   based on demand.
+         * - New threads are created as needed, and idle threads are reused if available.
+         * - Suitable for applications with a large number of short-lived tasks
+         *   or workloads that vary significantly.
+         *
+         *   Ek aisa thread pool banata hai jo dynamically threads ko adjust karta hai.
+         *   Jitne tasks aate hain, utne threads create kar deta hai (agar free threads available
+         *   ho to unhe reuse karta hai).
+         *   Ye short-lived tasks ke liye best hai, ya jab workload variable ho
+         *   (kabhi zyada load, kabhi kam load).
+         */
+        ExecutorService executorService = Executors.newCachedThreadPool();
+    }
+}