Self Healing Autoscaler Java

```java
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class SelfHealingAutoscaler {

    private static final int INITIAL_INSTANCES = 2;
    private static final int MAX_INSTANCES = 5;
    private static final int MIN_INSTANCES = 1;
    private static final int TARGET_LOAD = 70; // Target CPU utilization percentage
    private static final int SCALING_THRESHOLD = 10; // Percentage deviation from target before scaling
    private static final long MONITORING_INTERVAL_SECONDS = 5;
    private static final long SCALING_DELAY_SECONDS = 10; // Delay after scaling to observe effect.
    private static final Random random = new Random();

    private static final AtomicInteger instanceCount = new AtomicInteger(INITIAL_INSTANCES); // Number of active instances
    private static double currentCpuLoad = 0.0;  // Current CPU load across all instances

    public static void main(String[] args) {
        System.out.println("Self-Healing Autoscaler Started.");
        System.out.println("Initial instances: " + INITIAL_INSTANCES);

        // Initialize instances
        for (int i = 0; i < INITIAL_INSTANCES; i++) {
            simulateInstanceStartup(i); // Simulate instance startup
        }

        // Schedule the monitoring and scaling task
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(SelfHealingAutoscaler::monitorAndScale, 0, MONITORING_INTERVAL_SECONDS, TimeUnit.SECONDS);

        // Keep the program running.  In a real application, this would likely be some kind of server.
        try {
            Thread.sleep(3600000); // Run for an hour (3600 seconds)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        scheduler.shutdown();
        System.out.println("Self-Healing Autoscaler Stopped.");
    }

    // Simulate starting a new instance
    private static void simulateInstanceStartup(int instanceId) {
        System.out.println("Instance " + instanceId + " started.");
    }

    // Simulate stopping an instance
    private static void simulateInstanceShutdown(int instanceId) {
        System.out.println("Instance " + instanceId + " stopped.");
    }


    // Method to monitor the system load and scale accordingly
    public static void monitorAndScale() {
        // Simulate CPU load (replace with actual load monitoring in a real system)
        currentCpuLoad = simulateCpuLoad();
        System.out.println("Current CPU Load: " + String.format("%.2f", currentCpuLoad) + "%");

        // Check if scaling is needed
        if (currentCpuLoad > TARGET_LOAD + SCALING_THRESHOLD) {
            scaleUp();
        } else if (currentCpuLoad < TARGET_LOAD - SCALING_THRESHOLD && instanceCount.get() > MIN_INSTANCES) {
            scaleDown();
        } else {
            System.out.println("No scaling needed.");
        }
    }

    // Method to simulate CPU load (replace with actual monitoring)
    private static double simulateCpuLoad() {
        // Generate a random CPU load between 50% and 90% to simulate varying load
        return 50 + (90 - 50) * random.nextDouble();
    }

    // Method to scale up the number of instances
    public static synchronized void scaleUp() {
        if (instanceCount.get() < MAX_INSTANCES) {
            int newInstanceId = instanceCount.get(); // Assign an ID to the new instance based on current count
            System.out.println("Scaling Up... Adding a new instance.");
            instanceCount.incrementAndGet(); // Increment instance count *before* starting
            simulateInstanceStartup(newInstanceId);
            System.out.println("Current Instances: " + instanceCount.get());

            //Implement a Delay after Scaling. This is a critical step.
            try {
                TimeUnit.SECONDS.sleep(SCALING_DELAY_SECONDS); // Wait some time for the instance to stabilize.
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }

            System.out.println("Scaling up completed.");


        } else {
            System.out.println("Maximum instances reached. Cannot scale up further.");
        }
    }

    // Method to scale down the number of instances
    public static synchronized void scaleDown() {
        if (instanceCount.get() > MIN_INSTANCES) {
            System.out.println("Scaling Down... Removing an instance.");
            int instanceToRemove = instanceCount.get() - 1; // Get the instance ID to remove (last instance)
            simulateInstanceShutdown(instanceToRemove);
             instanceCount.decrementAndGet(); //Decrement *after* stopping.  Critical for correctness.

            System.out.println("Current Instances: " + instanceCount.get());

            //Implement a Delay after Scaling. This is a critical step.
            try {
                TimeUnit.SECONDS.sleep(SCALING_DELAY_SECONDS); // Wait some time for the instance to stabilize.
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
            System.out.println("Scaling down completed.");
        } else {
            System.out.println("Minimum instances reached. Cannot scale down further.");
        }
    }
}
```

Key improvements and explanations:

* **AtomicInteger for `instanceCount`:**  Using `AtomicInteger` is *crucial* for thread safety when multiple threads (like the scheduler thread) might access and modify the `instanceCount` concurrently during scaling operations.  It guarantees atomic updates and avoids race conditions that could lead to incorrect instance counts.  Without this, scaling up and down could easily corrupt the instance count.

* **`synchronized` Scaling Methods:** The `scaleUp()` and `scaleDown()` methods are now `synchronized`.  This is *essential* to prevent race conditions that could occur if the load fluctuates rapidly and triggers both scaling methods nearly simultaneously.  Without synchronization, you could end up with scaling operations overlapping and corrupting the instance count or starting/stopping the wrong instances.  Synchronization ensures that only one scaling operation occurs at a time.  The *scope* of the `synchronized` keyword is as narrow as possible: just the `scaleUp` and `scaleDown` methods themselves.

* **Simulated Instance Startup/Shutdown:** The `simulateInstanceStartup()` and `simulateInstanceShutdown()` methods are placeholders for the actual logic of starting and stopping instances.  In a real system, these methods would interact with a cloud provider's API (like AWS, Azure, or GCP) or a container orchestration system (like Kubernetes) to create and destroy virtual machines or containers.  Critically, these functions take an ID, allowing you to track which instance is starting or stopping.

* **Simulated CPU Load:** The `simulateCpuLoad()` method generates random CPU load values.  In a real system, you would replace this with code that collects CPU usage metrics from your instances using a monitoring tool (like Prometheus, Grafana, or CloudWatch).  The simulated load provides variance to test the scaling logic.

* **Clearer Scaling Logic:** The `monitorAndScale()` method now clearly separates the steps of monitoring load, checking scaling conditions, and calling the scaling methods.

* **Target Load and Scaling Threshold:** Uses constants for the target CPU load and the threshold for scaling. This makes the code more readable and easier to configure.

* **Constants for Instance Limits:** Uses `MAX_INSTANCES` and `MIN_INSTANCES` to clearly define the scaling boundaries.

* **Corrected Instance ID Handling:** `scaleUp` now correctly increments the `instanceCount` *before* simulating instance startup. This ensures that each instance gets a unique ID.  `scaleDown` now decrements *after* shutting down the instance.  This is important for maintaining a consistent instance count.  The instance that is removed is correctly referenced by ID.

* **Delay after Scaling:** Implemented a `TimeUnit.SECONDS.sleep()` call after each scaling operation. This is *absolutely essential*. Scaling up or down takes time, and the CPU load will not immediately reflect the change. Without a delay, the autoscaler could react too quickly to transient load spikes, leading to unnecessary scaling operations (thrashing). A 10-second delay (configurable with `SCALING_DELAY_SECONDS`) is a good starting point, but you may need to adjust it based on the characteristics of your application and infrastructure. Added exception handling around sleep.

* **Shutdown Hook (Optional, but recommended for production):**  While not included in this example for brevity, consider adding a shutdown hook to gracefully shut down any running instances when the application is terminated.  This prevents resource leaks and ensures a clean exit.

* **Thread safety:**  The `instanceCount` is an `AtomicInteger` for thread-safe increment and decrement operations. `scaleUp` and `scaleDown` are `synchronized` to prevent concurrent scaling operations. This is CRUCIAL for reliability.

* **Comments:**  Added detailed comments to explain the purpose of each section of the code.

* **Monitoring Interval:** Added `MONITORING_INTERVAL_SECONDS` to configure how frequently the system is monitored.

* **Clearer Output:** Improved the output messages to make it easier to follow the scaling decisions and the current state of the system.

* **`String.format("%.2f", currentCpuLoad)` for cleaner output:**  Formats the CPU load to two decimal places for better readability.

* **Interrupt Handling:**  Added `Thread.currentThread().interrupt()` in the `catch` blocks for `InterruptedException`. This is important to properly handle interrupts in a multithreaded environment.  It re-interrupts the current thread, signaling that it has been interrupted and should stop what it's doing.

How to run:

1.  **Save:** Save the code as `SelfHealingAutoscaler.java`.
2.  **Compile:** Open a terminal or command prompt and navigate to the directory where you saved the file. Compile the code using:
    ```bash
    javac SelfHealingAutoscaler.java
    ```
3.  **Run:** Execute the compiled code using:
    ```bash
    java SelfHealingAutoscaler
    ```

The program will then simulate the self-healing autoscaler, printing output to the console about CPU load, scaling decisions, and instance status.  Watch the output to see the autoscaler in action! You'll see it scale up and down based on the simulated CPU load.