feat: add ExecutorService with Callable tasks to wait for dependent services

WHAT was added:
- Implemented a Main2 class demonstrating use of ExecutorService with a fixed thread pool of 3 workers.
- Submitted three DependantServices tasks, each implementing Callable<String>.
- Each Callable prints a start message, simulates work with Thread.sleep(2000), and returns "Ok".
- Used Future<String> objects to wait for task completion via get().
- Printed a message confirming that all dependent services finished before starting main services.
- Cleanly shut down the ExecutorService.

WHY this matters:
- Shows how to use Callable instead of Runnable when tasks need to return values.
- Demonstrates waiting for multiple parallel tasks to complete before proceeding.
- Emulates a real-world scenario where dependent services (like DB, cache, API) must initialize before the main system starts.
- Reinforces proper shutdown of ExecutorService for resource management.

HOW it works:
1. A fixed thread pool of size 3 runs three DependantServices in parallel.
2. Each service prints a message and simulates work by sleeping 2 seconds.
3. Main thread calls future.get() on each Future, blocking until all tasks complete.
4. After all futures finish, prints confirmation message and shuts down executor.

NOTES and gotchas:
- future.get() is blocking; if one task takes longer, main waits until it finishes.
- Using invokeAll() could simplify submitting multiple Callable tasks at once.
- ExecutorService.shutdown() ensures no new tasks are accepted and resources are released.
- Returning "Ok" allows further aggregation or logging of service results if needed.

KEY TAKEAWAY:
- Use Callable<T> when you need tasks to return results.
- Use Future<T>.get() to block until completion and retrieve results.
- ExecutorService simplifies managing multiple parallel service initializations.

SHORT KEYS:
executorservice callable future parallel init services.

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

Author: Someshdiwan

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

@@ -0,0 +1,27 @@
+import javax.swing.plaf.FontUIResource;
+import java.util.concurrent.*;
+
+public class Main2 {
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        ExecutorService executorService = Executors.newFixedThreadPool(3);
+
+        Future<String> future1 = executorService.submit(new DependantServices());
+        Future<String> future2 = executorService.submit(new DependantServices());
+        Future<String> future3 = executorService.submit(new DependantServices());
+
+        future1.get();
+        future2.get();
+        future3.get();
+
+        System.out.println("All dependant services finished.Starting main services.");
+        executorService.shutdown();
+    }
+}
+class DependantServices implements Callable<String> {
+    @Override
+    public String call() throws Exception {
+        System.out.println(Thread.currentThread().getName() + " Services started.");
+        Thread.sleep(2000);
+        return "Ok";
+    }
+}