/* Example 1: Basic Interruption Mechanism */
public class InterruptDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            try {
                System.out.println("Worker thread started. Sleeping for 5 seconds...");
                // Thread.sleep is an interruptible blocking call
                Thread.sleep(5000);
                System.out.println("Worker thread finished sleeping.");
            } catch (InterruptedException e) {
                System.out.println("Worker thread interrupted during sleep!");
                // Crucially, InterruptedException clears the interrupt status.
                // Re-assert the interruption status for higher-level handlers if the thread isn't terminating.
                // If the thread is designed to terminate upon interruption, re-interrupting might not be strictly necessary
                // but is a good practice if further cleanup might involve interruptible operations.
                Thread.currentThread().interrupt(); // Re-interrupt to maintain status
            }
            System.out.println("Worker thread exiting.");
        });

        worker.start();
        Thread.sleep(1000); // Allow worker to start and enter sleep state
        System.out.println("Main thread interrupting worker...");
        worker.interrupt(); // Signal interruption to the worker thread
        worker.join(); // Wait for the worker thread to complete its termination
        System.out.println("Main thread finished.");
    }
}

/* Example 2: Implementing a Cooperatively Terminable Task */
public class SafeWorker implements Runnable {
    // Volatile flag ensures visibility of changes across threads
    private volatile boolean running = true;

    // Method to signal the thread to stop (called externally)
    public void signalStop() {
        this.running = false;
        // Note: The thread itself will check this flag. For blocking operations,
        // an explicit interrupt on the worker thread instance is also needed from the caller.
    }

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName + " started.");
        try {
            // Check both the volatile flag and interruption status within the loop
            while (running && !Thread.currentThread().isInterrupted()) {
                System.out.println(threadName + " is working...");
                // Simulate work that might take some time or block
                Thread.sleep(1000); // This is an interruptible blocking call
            }
        } catch (InterruptedException e) {
            System.out.println(threadName + " interrupted during work (caught InterruptedException).");
            // When InterruptedException is caught, the interrupted status is cleared.
            // If the thread is terminating, re-interrupting is often not necessary.
            // If the thread needs to perform more interruptible cleanup, re-interrupt.
            // Thread.currentThread().interrupt(); // Re-assert if further interruptible logic exists
        } finally {
            // Perform any necessary cleanup here, ensuring resources are closed regardless of termination path
            System.out.println(threadName + " performing cleanup...");
        }
        System.out.println(threadName + " finished.");
    }

    public static void main(String[] args) throws InterruptedException {
        SafeWorker task = new SafeWorker();
        Thread worker = new Thread(task, "SafeWorkerThread");

        worker.start();
        Thread.sleep(3500); // Let the worker run for a bit (approx 3 iterations)
        System.out.println("Main thread signaling worker to terminate...");

        // Correct way to stop: signal the task's volatile flag and then interrupt the thread.
        // Setting 'running = false' handles active loops (CPU-bound).
        // 'worker.interrupt()' handles blocking calls (e.g., Thread.sleep, wait, I/O).
        task.signalStop(); // Set the volatile flag to signal termination intent
        worker.interrupt(); // Interrupt the worker thread to unblock it from interruptible calls

        worker.join(); // Wait for the worker to finish its cleanup and exit
        System.out.println("Main thread finished.");
    }
}

/* Example 3: Managed Thread Termination with ExecutorService */
import java.util.concurrent.*;
import java.util.List;

public class ExecutorServiceTermination {

    // A simple cancellable task for the ExecutorService
    static class CancellableTask implements Runnable {
        private final int taskId;

        public CancellableTask(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();
            System.out.println("Task " + taskId + " running on " + threadName);
            try {
                // Simulate work that periodically checks for interruption
                for (int i = 0; i < 5; i++) {
                    // Explicitly check the interrupt status
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("Task " + taskId + " on " + threadName + " detected interruption, terminating gracefully.");
                        return; // Exit the run method gracefully
                    }
                    System.out.println("Task " + taskId + " on " + threadName + " working step " + i);
                    Thread.sleep(500); // Simulate blocking work, which is interruptible
                }
                System.out.println("Task " + taskId + " on " + threadName + " completed normally.");
            } catch (InterruptedException e) {
                System.out.println("Task " + taskId + " on " + threadName + " interrupted during sleep (caught InterruptedException).");
                // InterruptedException clears the interrupt status. For a task meant to terminate, usually no re-interrupt needed.
                // If cleanup or further processing needs to be interruptible, re-interrupt.
            } finally {
                System.out.println("Task " + taskId + " on " + threadName + " performing final cleanup.");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // Create an ExecutorService with a fixed thread pool size for demonstration
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // Submit multiple tasks for execution
        System.out.println("Submitting tasks to ExecutorService.");
        for (int i = 0; i < 5; i++) {
            executor.submit(new CancellableTask(i + 1));
        }

        Thread.sleep(2000); // Allow some tasks to run for a period

        System.out.println("Attempting graceful shutdown of ExecutorService...");
        executor.shutdown(); // Initiate a graceful shutdown: no new tasks, finish existing ones

        // Wait for all tasks to complete, with a timeout
        try {
            if (!executor.awaitTermination(3, TimeUnit.SECONDS)) {
                System.out.println("Tasks did not complete in time, forcing immediate shutdown...");
                // If graceful shutdown times out, use shutdownNow() to interrupt and force termination
                List<Runnable> outstandingTasks = executor.shutdownNow();
                System.out.println(outstandingTasks.size() + " tasks were outstanding and cancelled.");
            }
        } catch (InterruptedException e) {
            System.out.println("Main thread interrupted while waiting for executor termination.");
            Thread.currentThread().interrupt(); // Re-assert if main thread needs to handle interruption
        }

        System.out.println("ExecutorService has been fully shut down.");
        System.out.println("Main thread finished.");
    }
}