docs(concurrency): add detailed notes and examples on Executors Framework in Java

WHAT was added:
- Theory section explaining Executors Framework (introduced in Java 5, part of java.util.concurrent).
- Covered key motivations:
  • Efficient thread pooling (reuse threads instead of creating new ones).
  • Reduces thread creation overhead.
  • Provides pooling strategies and automatic lifecycle handling.
- Breakdown of core components:
  • Executor (basic interface with execute()).
  • ExecutorService (extends Executor, lifecycle + Future support).
  • Executors (factory class with pool creation methods).
  • Future (for async computation results).
- Table summarizing different thread pools:
  • newFixedThreadPool
  • newCachedThreadPool
  • newSingleThreadExecutor
  • newScheduledThreadPool
- Example 1: FixedThreadPool → shows 5 tasks running on 3 threads, with thread reuse.
- Example 2: ScheduledThreadPool → schedules a task with delay.

WHY this matters:
- Executors framework is the backbone of Java concurrency.
- Simplifies thread management, avoids boilerplate, prevents resource leaks.
- Provides different strategies suitable for I/O-bound, CPU-bound, or scheduled tasks.
- Using thread pools leads to more scalable and performant applications.

HOW it works:
- Executors.newFixedThreadPool(n) creates a pool of n reusable threads.
- Tasks beyond n wait in a queue until threads become free.
- Executors.newScheduledThreadPool(n) allows delayed/periodic execution.
- executor.shutdown() ensures resources are released properly.

HINTS:
- Always call shutdown() or shutdownNow() after using ExecutorService.
- FixedThreadPool → stable concurrency level (good for CPU-bound).
- CachedThreadPool → dynamic scaling (good for many short-lived tasks).
- SingleThreadExecutor → guarantees sequential execution.
- ScheduledThreadPool → replacement for Timer with better concurrency support.

KEYWORDS:
executors executorservice future threadpool scheduledexecutorservice concurrency java.

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

Author: Someshdiwan

Section19MultiThreading/ThreadPooling/src/ExecutorsFramework/Executors Framework in Java Thread Pooling.txt renamed to Section19MultiThreading/ThreadPooling/ExecutorsFramework/src/TXTFiles/Executors Framework in Java Thread Pooling.txt

@@ -1,10 +1,9 @@
-Executors Framework in Java (Thread Pooling)
+Executors Framework in Java (Thread Pooling):
 
 The Executors framework in Java (introduced in Java 5) provides a high-level API for managing thread pools efficiently.
 It is part of the java.util.concurrent package.
 
 Why Use Executors?
-
 - Manages Thread Pooling Efficiently 🏭
 - Reduces Thread Creation Overhead 🚀
 - Provides Different Pooling Strategies 🎯
@@ -20,7 +19,7 @@ Key Components of the Executors Framework:
 4. Future Interface → Handles asynchronous computation results.
 
 
-Types of Thread Pools in Executors Framework
+Types of Thread Pools in Executors Framework:
 
 | Thread Pool Type              | Description                                          |
 |-------------------------------|------------------------------------------------------|
@@ -80,4 +79,4 @@ Advantages of Executors Framework:
 ✅ Efficient Thread Management
 ✅ Avoids Manual Thread Creation & Destruction
 ✅ Provides Thread Pooling Strategies
-✅ Handles Concurrency Smoothly
+✅ Handles Concurrency Smoothly