/*
 * Base setup for a ForkJoinPool.
 * This pool manages worker threads and task execution.
 */
import java.util.concurrent.ForkJoinPool;

public class ForkJoinPoolSetup {

    public static void main(String[] args) {
        // Determine the optimal pool size, typically based on available CPU cores.
        // Runtime.getRuntime().availableProcessors() is a common heuristic.
        int poolSize = Runtime.getRuntime().availableProcessors();

        // Forge a new ForkJoinPool instance.
        // The commonPool() is also an option for applications to share a single pool.
        ForkJoinPool forkJoinPool = new ForkJoinPool(poolSize);

        System.out.println("ForkJoinPool activated with " + forkJoinPool.getParallelism() + " parallelism level.");

        // In a real application, you would now submit ForkJoinTasks to this pool.
        // Example: forkJoinPool.invoke(new MyRecursiveTask(data));

        // Always shut down the pool gracefully when no longer needed.
        // However, commonPool() typically manages its own lifecycle.
        forkJoinPool.shutdown();
        System.out.println("ForkJoinPool shut down.");
    }
}

/*
 * Conceptual representation of a Work-Stealing Queue (Deque) for a worker thread.
 * In a real ForkJoinPool, this is managed internally and highly optimized.
 * This code illustrates the 'idea' of local and stolen tasks.
 */
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Random;
import java.util.concurrent.ForkJoinTask;

public class WorkStealingConcept {

    // Simulate a worker thread's local task deque
    private Deque<Runnable> localTasks = new ArrayDeque<>();
    private String workerId;

    public WorkStealingConcept(String workerId) {
        this.workerId = workerId;
    }

    // Method to add a task (pushed to head for local processing)
    public void addTask(Runnable task) {
        localTasks.addFirst(task); // LIFO for local execution
        System.out.println(workerId + ": Added task. Queue size: " + localTasks.size());
    }

    // Method for a worker to execute its own tasks (from head)
    public void executeLocalTask() {
        if (!localTasks.isEmpty()) {
            Runnable task = localTasks.removeFirst();
            System.out.println(workerId + ": Executing local task.");
            task.run();
        } else {
            System.out.println(workerId + ": No local tasks. Must steal...");
        }
    }

    // Method for another worker to steal a task (from tail)
    public Runnable stealTask() {
        if (!localTasks.isEmpty()) {
            // Try to steal from the tail (FIFO for stealing)
            return localTasks.pollLast(); 
        }
        return null;
    }

    public static void main(String[] args) throws InterruptedException {
        WorkStealingConcept workerA = new WorkStealingConcept("Worker-A");
        WorkStealingConcept workerB = new WorkStealingConcept("Worker-B");

        // Worker A gets some tasks
        workerA.addTask(() -> System.out.println("Task A1 done by " + Thread.currentThread().getName()));
        workerA.addTask(() -> System.out.println("Task A2 done by " + Thread.currentThread().getName()));

        // Worker B is initially idle
        workerB.executeLocalTask(); // B has no tasks

        // Worker B attempts to steal from Worker A
        Runnable stolenTask = workerA.stealTask();
        if (stolenTask != null) {
            System.out.println("Worker-B: Stole a task!");
            new Thread(stolenTask, "Worker-B-Thread").start(); // Execute stolen task on B's thread
        } else {
            System.out.println("Worker-B: Could not steal.");
        }
        
        // Worker A continues its own tasks
        new Thread(() -> {
            workerA.executeLocalTask(); // A2 (LIFO)
            workerA.executeLocalTask(); // A1
        }, "Worker-A-Thread").start();

        Thread.sleep(100); // Give time for threads to complete
    }
}

/*
 * Demonstrates a RecursiveTask implementation for parallel summation of a large array.
 * This example highlights the 'divide and conquer' strategy and base case handling.
 */
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
import java.util.Random;

// Define a RecursiveTask to sum a portion of an array
class ParallelArraySumTask extends RecursiveTask<Long> {
    private static final int SEQUENTIAL_THRESHOLD = 10_000; // Threshold for sequential processing
    private final long[] array;
    private final int start;
    private final int end;

    public ParallelArraySumTask(long[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        // Base case: If the segment is small enough, compute sequentially.
        if (end - start <= SEQUENTIAL_THRESHOLD) {
            return computeSequentially();
        } else {
            // Recursive case: Divide the task into two subtasks.
            int mid = start + (end - start) / 2;

            // Forge the left subtask
            ParallelArraySumTask leftTask = new ParallelArraySumTask(array, start, mid);
            // Asynchronously execute the left subtask
            leftTask.fork(); 

            // Create and compute the right subtask directly in this thread
            ParallelArraySumTask rightTask = new ParallelArraySumTask(array, mid, end);
            Long rightResult = rightTask.compute(); // Recursive call, not fork

            // Join the left subtask's result (wait for its completion if not done)
            Long leftResult = leftTask.join();

            // Combine the results
            return leftResult + rightResult;
        }
    }

    // Helper method for sequential computation
    private Long computeSequentially() {
        long sum = 0;
        for (int i = start; i < end; i++) {
            sum += array[i];
        }
        // System.out.println(Thread.currentThread().getName() + " computed sequentially from " + start + " to " + end + ": " + sum);
        return sum;
    }

    public static void main(String[] args) {
        // 1. Prepare the data: A large array of random numbers
        int arraySize = 100_000_000; // 100 million elements
        long[] data = new long[arraySize];
        Random random = new Random();
        for (int i = 0; i < arraySize; i++) {
            data[i] = random.nextInt(100); // Values between 0 and 99
        }

        // Calculate expected sum for verification
        long expectedSum = 0;
        for (long num : data) {
            expectedSum += num;
        }
        System.out.println("Expected Sequential Sum: " + expectedSum);

        // 2. Forge a ForkJoinPool
        ForkJoinPool pool = new ForkJoinPool();

        // 3. Create the main task and submit it to the pool
        ParallelArraySumTask mainTask = new ParallelArraySumTask(data, 0, data.length);

        long startTime = System.nanoTime();
        // Invoke the task and get the result
        Long parallelSum = pool.invoke(mainTask);
        long endTime = System.nanoTime();

        System.out.println("Parallel Sum: " + parallelSum);
        System.out.println("Time taken: " + (endTime - startTime) / 1_000_000 + " ms");

        // 4. Verify the result
        if (parallelSum.equals(expectedSum)) {
            System.out.println("Result verification successful!");
        } else {
            System.err.println("Result verification FAILED! Discrepancy detected.");
        }

        // 5. Shut down the ForkJoinPool (important for resource management)
        pool.shutdown();
    }
}

/*
 * Code snippets illustrating best practices and common pitfalls.
 */
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.ForkJoinWorkerThread;
import java.util.concurrent.locks.ReentrantLock;

public class ForkJoinOptimization {

    // 1. Task Granularity: Choosing the right threshold is critical.
    // Too small -> excessive overhead. Too large -> insufficient parallelism.
    private static final int OPTIMAL_THRESHOLD = 5_000; // Example, needs empirical tuning

    // 2. Avoiding Blocking Operations: ForkJoinPool threads are not for blocking I/O or heavy synchronization.
    // If blocking is unavoidable, use ManagedBlocker.
    static class BlockingTask extends RecursiveAction {
        private final ReentrantLock lock;

        BlockingTask(ReentrantLock lock) { this.lock = lock; }

        @Override
        protected void compute() {
            System.out.println(Thread.currentThread().getName() + ": Attempting to acquire lock.");
            lock.lock(); // This blocks the ForkJoinWorkerThread!
            try {
                // Simulate blocking operation or heavy synchronization
                System.out.println(Thread.currentThread().getName() + ": Acquired lock, simulating work.");
                try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            } finally {
                lock.unlock();
                System.out.println(Thread.currentThread().getName() + ": Released lock.");
            }
        }
    }

    // ManagedBlocker usage (conceptual - would wrap the blocking logic)
    // ForkJoinPool.managedBlock(new MyManagedBlocker());

    public static void main(String[] args) throws InterruptedException {
        ForkJoinPool pool = new ForkJoinPool(2); // Small pool to demonstrate blocking issue

        System.out.println("\n--- Demonstrating Blocking Issue ---");
        ReentrantLock sharedLock = new ReentrantLock();
        for (int i = 0; i < 4; i++) { // More tasks than threads
            pool.execute(new BlockingTask(sharedLock));
        }

        // In a real scenario, this could lead to deadlocks or thread starvation
        // because ForkJoinPool threads might all block, preventing new tasks from running.
        // We wait for a bit to let it run, but this scenario is problematic.
        Thread.sleep(500); 
        System.out.println("Pool state after potential blocking: " + pool);

        pool.shutdown();
        pool.awaitTermination(1, java.util.concurrent.TimeUnit.SECONDS);
        System.out.println("ForkJoinPool shut down.");

        // 3. Exception Handling: Exceptions in subtasks propagate via join().
        // They are rethrown as CompletionException or unchecked exceptions.
        // It's crucial to catch them when calling join().
        // For RecursiveAction, consider catching inside compute() or checking for exceptions.

        // 4. Pool Size: Defaults to availableProcessors, generally optimal.
        // Custom sizing (e.g., for very specific hardware) requires careful benchmarking.

        // 5. Debugging & Monitoring: Use debugger's thread view. For monitoring, 
        // ForkJoinPool provides metrics like getQueuedTaskCount(), getRunningThreadCount(), etc.

        // 6. Immutability: Tasks should ideally work on immutable data or distinct portions
        // of mutable data to avoid race conditions and synchronization overhead.
    }
}