/*
 * Java Flight Recorder (JFR) Fundamentals:
 * Enabling JFR and initiating a recording.
 * This code snippet demonstrates how to start a Java application
 * with JFR enabled and immediately begin a recording session.
 *
 * To execute:
 * 1. Compile your Java application (e.g., MyApplication.java).
 *    javac MyApplication.java
 * 2. Run with JFR arguments.
 *    java -XX:+FlightRecorder -XX:StartFlightRecording=duration=60s,filename=my_recording.jfr MyApplication
 *
 * Explanation of JVM Arguments:
 * -XX:+FlightRecorder: Activates JFR capabilities within the JVM.
 * -XX:StartFlightRecording: Instructs JFR to start a recording session immediately upon JVM startup.
 *    duration=60s: Specifies the recording duration (e.g., 60 seconds).
 *    filename=my_recording.jfr: Designates the output file path for the recording.
 *    Other useful options include: delay=5s (start recording after a delay),
 *    disk=true (stream to disk to handle large recordings, default is memory buffer),
 *    settings=profile (use a predefined template like 'default' or 'profile').
 */

// Example Java Application (MyApplication.java)
public class MyApplication {

    private static volatile boolean running = true;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("MyApplication started. Simulating work...");

        // Simulate some CPU-bound work and object allocation
        long startTime = System.currentTimeMillis();
        while (running && (System.currentTimeMillis() - startTime) < 55000) { // Run for ~55 seconds to fit 60s recording
            performCPUIntensiveTask();
            allocateMemory();
            Thread.sleep(10); // Small pause
        }

        System.out.println("MyApplication finished.");
    }

    private static void performCPUIntensiveTask() {
        long result = 0;
        for (int i = 0; i < 10000; i++) {
            result += Math.sqrt(i) * Math.sin(i);
        }
    }

    private static void allocateMemory() {
        // Simulate object allocation, which JFR can track for GC analysis
        Object[] tempArray = new Object[1000];
        for (int i = 0; i < tempArray.length; i++) {
            tempArray[i] = new String("Heap String " + i);
        }
        // tempArray will be eligible for GC after this method returns
    }

    // Method to stop the application gracefully (e.g., via a shutdown hook or signal)
    public static void stop() {
        running = false;
    }
}

/*
 * Decoding Performance Metrics with Java Mission Control (JMC):
 * This section focuses on launching JMC and loading a JFR recording file.
 * JMC is a powerful visualization tool for .jfr files.
 *
 * To launch JMC:
 * 1. Ensure you have a JDK installation (JMC is bundled with JDK 8, or can be downloaded separately for JDK 11+).
 * 2. Navigate to your JDK's bin directory or ensure it's in your PATH.
 *    cd $JAVA_HOME/bin
 * 3. Execute JMC.
 *    jmc
 *
 * Once JMC is launched:
 * 1. In the JMC UI, go to 'File' -> 'Open File...'
 * 2. Browse to and select your '.jfr' recording file (e.g., 'my_recording.jfr' generated in the previous step).
 * 3. JMC will load the recording and present various analysis tabs.
 *
 * Key areas within JMC to explore after loading a JFR file:
 * - 'Overview' tab: Provides a high-level summary of the recording.
 * - 'Event Browser': Detailed view of all captured events, filterable.
 * - 'Threads' tab: Visualizes thread activity, states, and contention.
 * - 'Memory' tab: Analyzes heap usage, garbage collection pauses, and object allocation hotspots.
 * - 'Hot Methods' / 'Method Profiling': Identifies CPU-intensive methods and code paths.
 * - 'I/O' tab: Monitors file and socket I/O operations.
 * - 'Code' tab: Explores JIT compilation details and code cache usage.
 *
 * This demonstration is primarily conceptual for UI interaction as JMC is a graphical tool.
 * The most crucial 'code' here is the command to launch JMC itself.
 */

// No specific Java application code required for this step, as it's about using the JMC tool.

/*
 * Advanced JFR Profiling Strategies:
 * This section demonstrates customizing JFR event settings and using the JFR API.
 * We will focus on creating a custom JFR configuration file and using jcmd for dynamic control.
 *
 * Scenario: Create a custom JFR profile to only record specific events with higher frequency.
 * For example, we want to closely monitor object allocation and method samples.
 *
 * Step 1: Create a custom JFR configuration file (e.g., 'custom_profile.jfc').
 * This XML file defines which events to enable and their thresholds/frequencies.
 */

// custom_profile.jfc (XML file content)
/*
<?xml version="1.0" encoding="UTF-8"?>
<configuration version="2.0" label="Custom Performance Profile" description="Records object allocation and method samples with higher precision.">
    <event name="jdk.GarbageCollection" enabled="true" period="everyChunk" stackTrace="true"/>
    <event name="jdk.ObjectAllocationInNewTLAB" enabled="true" stackTrace="true" threshold="0 ns"/>
    <event name="jdk.ObjectAllocationOutsideTLAB" enabled="true" stackTrace="true" threshold="0 ns"/>
    <event name="jdk.MethodSample" enabled="true" period="10 ms" stackTrace="true"/>
    <event name="jdk.ThreadPark" enabled="true" stackTrace="true" threshold="5 ms"/>
    <event name="jdk.JavaMonitorEnter" enabled="true" stackTrace="true" threshold="5 ms"/>
</configuration>
*/

/*
 * Step 2: Run your Java application with the custom profile.
 *    java -XX:+FlightRecorder -XX:StartFlightRecording=settings=custom_profile.jfc,duration=60s,filename=custom_recording.jfr MyApplication
 *
 * Explanation:
 * - settings=custom_profile.jfc: Points JFR to use our custom configuration.
 * - This allows fine-grained control over which events are collected and at what granularity.
 *
 * Step 3: Dynamic control using jcmd for a running JVM.
 * This assumes 'MyApplication' is already running (e.g., 'java MyApplication').
 * Find the PID of your running Java application first:
 *    jps -l
 * Let's assume PID is 12345.
 *
 * Start a recording with the custom profile on a running JVM:
 *    jcmd 12345 JFR.start name=MyCustomRecording,settings=custom_profile.jfc,duration=30s,filename=dynamic_custom_recording.jfr
 *
 * Dump the recording before it finishes (optional):
 *    jcmd 12345 JFR.dump name=MyCustomRecording,filename=dumped_custom_recording.jfr
 *
 * Stop the recording:
 *    jcmd 12345 JFR.stop name=MyCustomRecording
 *
 * This demonstrates precise, on-demand profiling tailored to specific performance hypotheses.
 *
 * Further advanced concept: Using the JFR API for programmatic control (Java 11+).
 * This involves using the `jdk.jfr` module. Example snippet (not full executable code here, just API usage).
 */
/*
import jdk.jfr.Configuration;
import jdk.jfr.Recording;
import java.io.IOException;
import java.nio.file.Paths;

public class ProgrammaticJFR {
    public static void main(String[] args) throws IOException, InterruptedException {
        // Load a custom configuration (e.g., from custom_profile.jfc)
        Configuration config = Configuration.create("custom_profile.jfc");

        // Create a new recording based on the configuration
        Recording recording = new Recording(config);
        recording.setName("Programmatic Recording");
        recording.setDestination(Paths.get("programmatic_recording.jfr"));
        recording.start();

        System.out.println("Programmatic JFR recording started for 10 seconds...");
        Thread.sleep(10000); // Simulate application work for 10 seconds

        recording.stop();
        recording.close();
        System.out.println("Programmatic JFR recording stopped and saved.");
    }
}
*/

/*
 * Engineering Performance Gains: Actionable Insights from JFR/JMC.
 * This section focuses on interpreting JFR/JMC data to derive actionable optimization steps.
 * While this isn't executable code, it outlines the analytical process.
 *
 * Scenario: Analyzing a 'my_recording.jfr' file to identify and resolve performance issues.
 *
 * 1. Load 'my_recording.jfr' into JMC.
 *
 * 2. Focus on the 'Overview' tab:
 *    - High CPU Usage: Indicates CPU-bound operations. Look at 'Method Profiling' / 'Hot Methods'.
 *    - Frequent GC Pauses: Suggests high object allocation rate or inefficient memory management. Dive into 'Memory' tab.
 *    - High Thread Contention: Points to synchronization issues. Explore 'Threads' tab.
 *
 * 3. Deep Dive - Example 1: High CPU usage (Method Profiling).
 *    - In JMC, navigate to 'Method Profiling'.
 *    - Identify methods consuming the most CPU time (usually shown as flame graphs or call trees).
 *    - Action: Optimize these 'hot' methods. Refactor algorithms, reduce unnecessary computations, cache results.
 *      Example: If 'MyApplication.performCPUIntensiveTask()' is hot, rewrite it for better efficiency.
 */

// Illustrative Java Code demonstrating a potential optimization (conceptual)
/*
public class OptimizedApplication {
    private static double[] precomputedSines = new double[10000];
    private static boolean initialized = false;

    public static void init() {
        if (!initialized) {
            for (int i = 0; i < 10000; i++) {
                precomputedSines[i] = Math.sin(i); // Precompute values
            }
            initialized = true;
        }
    }

    private static void performOptimizedCPUIntensiveTask() {
        init(); // Ensure precomputation happens once
        long result = 0;
        for (int int_i = 0; int_i < 10000; int_i++) {
            result += Math.sqrt(int_i) * precomputedSines[int_i]; // Use precomputed values
        }
    }
    // ... rest of the application using performOptimizedCPUIntensiveTask
}
*/

/*
 * 4. Deep Dive - Example 2: Excessive Object Allocation (Memory Tab).
 *    - In JMC, navigate to 'Memory' tab, specifically 'Allocations' or 'Heap Statistics'.
 *    - Look for classes with high allocation rates, especially outside TLABs.
 *    - Action: Reduce object creation. Reuse objects (object pooling), use primitive types/arrays, optimize String operations.
 *      Example: If 'new String("Heap String " + i)' shows up as a hotspot, consider using a StringBuilder or interned strings if appropriate.
 *
 * 5. Deep Dive - Example 3: Thread Contention (Threads Tab).
 *    - In JMC, go to 'Threads' tab -> 'Lock Instances' or 'Thread Dump'.
 *    - Identify monitors with high contention or threads frequently blocked.
 *    - Action: Refactor synchronization mechanisms. Reduce critical section size, use non-blocking data structures, optimize locking strategies.
 *
 * 6. Integration into CI/CD (Conceptual):
 *    - Automate JFR recording during performance tests.
 *    - Use JFR event streaming API or `jfr` tool to extract key metrics (e.g., GC pause times, allocation rates).
 *    - Compare metrics against baselines. Fail build if deviations exceed thresholds.
 *
 * This iterative process of recording, analyzing, identifying, and optimizing is key to continuous performance improvement.
 */