feat(executors): implement factorial computation using ExecutorService with fixed thread pool

WHAT was added:
- Java demo program (`Main`) showcasing `ExecutorService` with `Executors.newFixedThreadPool(3)`.
- Computes factorials of numbers 1–9 concurrently across 3 worker threads.
- Introduced `executor.submit()` for task submission instead of manual thread creation.
- Used `executor.shutdown()` and `awaitTermination()` to gracefully stop the pool.
- Added simulated workload via `Thread.sleep(1000)` to demonstrate concurrent execution.
- Printed total execution time for performance comparison.

WHY this matters:
- Demonstrates how to offload CPU-bound or time-consuming tasks (factorial calculation) to a managed thread pool.
- Highlights benefits of thread pooling:
  • Efficient reuse of worker threads.
  • Controlled concurrency (3 threads max at a time).
  • Automatic queuing of extra tasks until threads free up.
- Shows best practices with graceful shutdown (`shutdown()` + `awaitTermination()`).

HINTS / NEXT STEPS:
- Try replacing `newFixedThreadPool(3)` with:
  • `newSingleThreadExecutor()` → sequential execution.
  • `newCachedThreadPool()` → dynamic thread allocation.
- Use `Future<Long>` with `submit(Callable<Long>)` to capture and return factorial results.
- Experiment with different pool sizes to measure execution time differences.

KEYWORDS:
executors executorservice threadpool factorial concurrency fixedthreadpool java-multithreading graceful-shutdown.

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

Author: Someshdiwan

Section19MultiThreading/ThreadPooling/ExecutorsFramework/src/Main.java

@@ -0,0 +1,52 @@
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Author: Somesh Diwan
+ * Date: 16-Sep-2025
+ * Time: 19:49
+ * Description: Demonstration of using ExecutorService with a fixed thread pool
+ * to compute factorials concurrently.
+ * © Somesh Diwan. All rights reserved.
+ */
+
+public class Main {
+    public static void main(String[] args) {
+        long startTime = System.currentTimeMillis();
+
+        ExecutorService executor = Executors.newFixedThreadPool(3); //creating thread pool.
+
+        //Executors.newSingleThreadExecutor(); //there is lot's of method like this.
+
+        for (int i = 1; i < 10; i++) {
+            int finalI = i;
+
+            executor.submit( () -> {
+                long result = factorial(finalI);
+                System.out.println(result);
+            });
+        }
+        executor.shutdown(); //Manually shutdown.
+
+        try {
+            executor.awaitTermination(100, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        System.out.println("Total time: " + (System.currentTimeMillis() - startTime));
+    }
+
+    private static long factorial(int n) {
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        long result = 1;
+        for (int i = 1; i <= n; i++) {
+            result *= i;
+        }
+        return result;
+    }
+}