feat: convert CyclicBarrier subsystem startup demo to use ExecutorService with graceful shutdown

WHAT was added:
- MainWithExecutorService demonstrating subsystem startup coordination using:
  - CyclicBarrier to synchronize four subsystems (Web Server, Database, Cache, Messaging Service).
  - ExecutorService with a fixed thread pool sized to numberOfSubsystems to manage worker threads.
- Subsystem Runnable that:
  - Simulates initialization via Thread.sleep(initializationTimeMillis).
  - Calls barrier.await() after initialization so all subsystems wait at the barrier.
  - Logs lifecycle events: starting, initialization complete, waiting at barrier, and proceeding after barrier.
- Main performs orderly shutdown:
  - executor.shutdown() followed by awaitTermination with a timeout.
  - Forceful shutdown via shutdownNow() if tasks do not finish in time.
  - Proper interrupt handling in the shutdown path.

WHY this matters:
- Shows a production-friendly pattern that combines high-level concurrency utilities:
  - ExecutorService handles thread lifecycle and pooling for resource efficiency.
  - CyclicBarrier ensures all subsystems reach the same readiness checkpoint before continuing.
- Demonstrates robust program termination and resource cleanup, which is essential in real systems.
- Practical for real-world cases such as orchestrating microservice initialization, multi-component startup, and phased pipelines.

HOW it works:
1. Create CyclicBarrier with party count equal to numberOfSubsystems and a barrier action that prints a completion message.
2. Create a fixed thread pool ExecutorService and submit one Subsystem task per component.
3. Each Subsystem sleeps to simulate startup work, then calls barrier.await(). When the last party arrives:
   - Barrier action runs.
   - All participant threads are released concurrently to proceed.
4. Main calls executor.shutdown() and waits up to 10 seconds for termination.
   - If threads fail to terminate, main triggers executor.shutdownNow() to interrupt remaining tasks and logs forcing shutdown.
5. Subsystem code handles InterruptedException by restoring interrupt status and BrokenBarrierException by logging an error.

NOTES, GOTCHAS, and RECOMMENDATIONS:
- Use awaitTermination with a reasonable timeout to avoid indefinite blocking in main.
- Always handle BrokenBarrierException in tasks; it can occur if another thread is interrupted or the barrier is reset.
- If subsystem initialization is long-running or can hang, prefer shutdownNow() plus cooperative interruption in the task logic.
- For many short tasks or dynamic workloads, consider ForkJoinPool or work-stealing to improve throughput and load balancing.
- If barrier action performs heavy work, run that action in a separate thread or keep it lightweight to avoid delaying participants.
- For multi-phase synchronization, reuse CyclicBarrier across phases, or create one barrier per phase depending on complexity.

PERF and HARDWARE CONSIDERATIONS:
- Thread count should generally match available hardware threads for CPU bound tasks. For IO-bound initialization, a larger pool may be acceptable.
- On NUMA systems, consider data and thread affinity for improved cache locality when initialization touches large shared state.

SHORT KEY:
cyclicbarrier executorservice subsystem startup graceful-shutdown barrier-action.

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

Author: Someshdiwan

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

@@ -0,0 +1,66 @@
+import java.util.concurrent.*;
+
+/**
+ * ExecutorService version of the CyclicBarrier subsystem startup example.
+ */
+public class MainWithExecutorService {
+    public static void main(String[] args) {
+        int numberOfSubsystems = 4;
+
+        // Barrier action: runs once when all subsystems reach the barrier
+        CyclicBarrier barrier = new CyclicBarrier(numberOfSubsystems, () ->
+                System.out.println("All subsystems are up and running. System startup complete.")
+        );
+
+        // Use a fixed thread pool to manage threads
+        ExecutorService executor = Executors.newFixedThreadPool(numberOfSubsystems);
+
+        // Submit subsystem tasks to the executor
+        executor.submit(new Subsystem("Web Server", 2000, barrier));
+        executor.submit(new Subsystem("Database", 4000, barrier));
+        executor.submit(new Subsystem("Cache", 3000, barrier));
+        executor.submit(new Subsystem("Messaging Service", 3500, barrier));
+
+        // orderly shutdown and wait for completion
+        executor.shutdown();
+        try {
+            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
+                System.out.println("Forcing shutdown...");
+                executor.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            executor.shutdownNow();
+            Thread.currentThread().interrupt();
+        }
+
+        System.out.println("Main finished.");
+    }
+}
+
+class Subsystem implements Runnable {
+    private final String name;
+    private final int initializationTimeMillis;
+    private final CyclicBarrier barrier;
+
+    public Subsystem(String name, int initializationTimeMillis, CyclicBarrier barrier) {
+        this.name = name;
+        this.initializationTimeMillis = initializationTimeMillis;
+        this.barrier = barrier;
+    }
+
+    @Override
+    public void run() {
+        try {
+            System.out.println(name + " starting initialization...");
+            Thread.sleep(initializationTimeMillis); // simulate initialization work
+            System.out.println(name + " initialization complete. Waiting at barrier...");
+            barrier.await(); // wait for other subsystems
+            System.out.println(name + " proceeding after barrier.");
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            System.err.println(name + " was interrupted.");
+        } catch (BrokenBarrierException e) {
+            System.err.println(name + " barrier broken: " + e.getMessage());
+        }
+    }
+}