import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;
import java.util.ArrayList;
import java.util.List;

/**
 * Comprehensive Multithreading Example in Java
 * 
 * WHAT IS MULTITHREADING?
 * Multithreading allows your program to run multiple tasks simultaneously (concurrently).
 * Instead of doing one thing at a time, you can have multiple "threads" of execution
 * working on different tasks at the same time.
 * 
 * WHY USE MULTITHREADING?
 * - Better performance: While one thread waits for I/O, others can continue working
 * - Responsive user interfaces: UI stays responsive while background tasks run
 * - Parallel processing: Utilize multiple CPU cores effectively
 * - Better resource utilization: Keep CPU busy instead of waiting
 * 
 * KEY CONCEPTS COVERED:
 * - Thread creation and management (3 different ways)
 * - Synchronization mechanisms (preventing data corruption)
 * - Thread pools and executors (efficient thread management)
 * - Atomic operations (thread-safe operations without locks)
 * - Producer-Consumer pattern (classic synchronization pattern)
 * - CompletableFuture (modern asynchronous programming)
 * 
 * IMPORTANT: Multithreading can be tricky! Always be careful with shared data.
 */
public class MultithreadingExample {
    
    // ===== SHARED RESOURCES FOR DEMONSTRATION =====
    // These variables will be accessed by multiple threads simultaneously
    // This is where problems can occur if not handled properly!
    
    private static int sharedCounter = 0;  // A simple counter that multiple threads will modify
    private static final Object lock = new Object();  // A lock object for synchronization
    // Note: ReentrantLock is demonstrated in the ThreadSafeCounter class below
    private static final AtomicInteger atomicCounter = new AtomicInteger(0);  // Thread-safe counter
    
    // Producer-Consumer shared data
    // This list will be shared between producer and consumer threads
    private static final List<Integer> sharedList = new ArrayList<>();
    private static final int MAX_SIZE = 5;  // Maximum items the list can hold
    
    public static void main(String[] args) {
        System.out.println("=== Java Multithreading Examples ===\n");
        
        // Example 1: Basic Thread Creation
        basicThreadExample();
        
        // Example 2: Thread Synchronization
        synchronizationExample();
        
        // Example 3: Thread Pools
        threadPoolExample();
        
        // Example 4: Atomic Operations
        atomicOperationsExample();
        
        // Example 5: Producer-Consumer Pattern
        producerConsumerExample();
        
        // Example 6: CompletableFuture
        completableFutureExample();
    }
    
    /**
     * Example 1: Basic Thread Creation and Management
     * 
     * WHAT IS A THREAD?
     * A thread is like a separate path of execution in your program.
     * Think of it as having multiple workers doing different tasks at the same time.
     * 
     * THREE WAYS TO CREATE THREADS:
     * 1. Extending Thread class (old way, not recommended for new code)
     * 2. Implementing Runnable interface (recommended)
     * 3. Using lambda expressions (modern, clean way)
     * 
     * WHY IMPLEMENT RUNNABLE INSTEAD OF EXTENDING THREAD?
     * - Java doesn't allow multiple inheritance, so extending Thread limits your options
     * - Runnable is more flexible - you can implement other interfaces too
     * - Better separation of concerns - the task is separate from the thread
     */
    private static void basicThreadExample() {
        System.out.println("1. Basic Thread Creation:");
        System.out.println("   (Watch how all three threads run at the same time!)\n");
        
        // ===== METHOD 1: EXTENDING THREAD CLASS =====
        // This is the old way - not recommended for new code
        // We create a new class that extends Thread and override the run() method
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                // This code will run in a separate thread
                for (int i = 0; i < 5; i++) {
                    System.out.println("Thread 1 - Count: " + i);
                    try {
                        Thread.sleep(100);  // Sleep for 100ms (simulate work)
                    } catch (InterruptedException e) {
                        // If someone interrupts this thread, stop gracefully
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        };
        
        // ===== METHOD 2: IMPLEMENTING RUNNABLE INTERFACE =====
        // This is the recommended way - more flexible
        // We pass a Runnable object to the Thread constructor
        Thread thread2 = new Thread(() -> {
            // This lambda expression implements the Runnable interface
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread 2 - Count: " + i);
                try {
                    Thread.sleep(150);  // Sleep for 150ms
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        
        // ===== METHOD 3: USING LAMBDA EXPRESSION =====
        // This is the modern, clean way to create threads
        // The lambda automatically implements Runnable
        Thread thread3 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread 3 - Count: " + i);
                try {
                    Thread.sleep(200);  // Sleep for 200ms
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        
        // ===== STARTING THREADS =====
        // start() begins the thread execution
        // If you call run() instead of start(), it runs in the current thread (not what we want!)
        thread1.start();
        thread2.start();
        thread3.start();
        
        // ===== WAITING FOR THREADS TO COMPLETE =====
        // join() makes the current thread wait until the specified thread finishes
        // This ensures we don't exit the program before all threads are done
        try {
            thread1.join();  // Wait for thread1 to finish
            thread2.join();  // Wait for thread2 to finish
            thread3.join();  // Wait for thread3 to finish
        } catch (InterruptedException e) {
            // If the current thread is interrupted while waiting, handle it
            Thread.currentThread().interrupt();
        }
        
        System.out.println("Basic thread example completed.\n");
    }
    
    /**
     * Example 2: Thread Synchronization
     * 
     * WHAT IS SYNCHRONIZATION?
     * When multiple threads access the same data at the same time, problems can occur.
     * Synchronization ensures that only one thread can access shared data at a time.
     * 
     * THE PROBLEM WITHOUT SYNCHRONIZATION:
     * - Race conditions: Two threads might read the same value, modify it, and write back
     * - Data corruption: The final result might be wrong
     * - Unpredictable behavior: Results vary between runs
     * 
     * THE SOLUTION: SYNCHRONIZED BLOCKS
     * - Only one thread can enter a synchronized block at a time
     * - Other threads must wait until the current thread exits
     * - This prevents race conditions and ensures data integrity
     * 
     * WHY IS THIS IMPORTANT?
     * Imagine two people trying to update the same bank account balance at once!
     * Without synchronization, money could be lost or duplicated.
     */
    private static void synchronizationExample() {
        System.out.println("2. Thread Synchronization:");
        System.out.println("   (5 threads each incrementing a counter 1000 times)");
        System.out.println("   (Expected result: 5000, but without sync it might be less!)\n");
        
        // Reset shared counter to 0
        sharedCounter = 0;
        
        // Create 5 threads that will all try to increment the same counter
        Thread[] threads = new Thread[5];
        
        for (int i = 0; i < 5; i++) {
            final int threadId = i;  // Need final for use in lambda
            threads[i] = new Thread(() -> {
                // Each thread will increment the counter 1000 times
                for (int j = 0; j < 1000; j++) {
                    // ===== SYNCHRONIZED BLOCK =====
                    // This ensures only one thread can access sharedCounter at a time
                    // The 'lock' object is used as a "key" - only one thread can hold it
                    synchronized (lock) {
                        sharedCounter++;  // This operation is now thread-safe
                    }
                    // When this block ends, the lock is released for other threads
                }
                System.out.println("Thread " + threadId + " completed");
            });
        }
        
        // Start all 5 threads at the same time
        for (Thread thread : threads) {
            thread.start();
        }
        
        // Wait for all threads to complete their work
        for (Thread thread : threads) {
            try {
                thread.join();  // Wait for this specific thread to finish
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        
        // Display the final result
        System.out.println("Final shared counter value: " + sharedCounter);
        System.out.println("   (Should be exactly 5000 if synchronization worked correctly)");
        System.out.println("Synchronization example completed.\n");
    }
    
    /**
     * Example 3: Thread Pools and Executors
     * 
     * WHAT IS A THREAD POOL?
     * Instead of creating and destroying threads constantly, we create a "pool" of reusable threads.
     * This is much more efficient than creating new threads for each task.
     * 
     * WHY USE THREAD POOLS?
     * - Performance: Creating/destroying threads is expensive
     * - Resource management: Limits the number of threads (prevents system overload)
     * - Reusability: Threads can be reused for multiple tasks
     * - Better control: Easy to manage and monitor thread usage
     * 
     * TYPES OF THREAD POOLS:
     * - FixedThreadPool: Fixed number of threads
     * - CachedThreadPool: Creates threads as needed, reuses idle ones
     * - SingleThreadExecutor: Only one thread (tasks run sequentially)
     * - ScheduledThreadPool: For delayed or periodic tasks
     * 
     * EXECUTORSERVICE:
     * - Manages the thread pool
     * - Submits tasks for execution
     * - Returns Future objects to get results
     * - Must be shut down when done!
     */
    private static void threadPoolExample() {
        System.out.println("3. Thread Pools and Executors:");
        System.out.println("   (10 tasks will be executed by 3 reusable threads)\n");
        
        // ===== CREATE A FIXED THREAD POOL =====
        // This creates a pool with exactly 3 threads
        // These threads will be reused for all our tasks
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        // ===== SUBMIT TASKS TO THE THREAD POOL =====
        // We'll create 10 tasks but only 3 threads will handle them
        // Tasks will be queued and executed as threads become available
        List<Future<String>> futures = new ArrayList<>();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;  // Need final for lambda
            // Submit a task to the thread pool
            // This returns a Future object that we can use to get the result later
            Future<String> future = executor.submit(() -> {
                try {
                    // Simulate some work (1 second)
                    Thread.sleep(1000);
                    // Return a result with the task ID and thread name
                    return "Task " + taskId + " completed by " + Thread.currentThread().getName();
                } catch (InterruptedException e) {
                    // Handle interruption gracefully
                    Thread.currentThread().interrupt();
                    return "Task " + taskId + " interrupted";
                }
            });
            futures.add(future);  // Store the Future object for later
        }
        
        // ===== COLLECT RESULTS =====
        // Now we'll get the results from all our tasks
        // The get() method blocks until the task completes
        for (Future<String> future : futures) {
            try {
                System.out.println(future.get());  // Get the result (this might wait)
            } catch (InterruptedException | ExecutionException e) {
                System.err.println("Error getting result: " + e.getMessage());
            }
        }
        
        // ===== SHUTDOWN THE EXECUTOR =====
        // IMPORTANT: Always shut down the executor when done!
        // This prevents the program from hanging
        executor.shutdown();
        try {
            // Wait up to 60 seconds for all tasks to complete
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                // If tasks don't finish in time, force shutdown
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            // If interrupted while waiting, force shutdown
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
        
        System.out.println("Thread pool example completed.\n");
    }
    
    /**
     * Example 4: Atomic Operations
     * 
     * WHAT ARE ATOMIC OPERATIONS?
     * Atomic operations are operations that complete in a single step without interruption.
     * They are thread-safe by design - no synchronization needed!
     * 
     * WHY USE ATOMIC OPERATIONS?
     * - Thread-safe: No need for synchronized blocks
     * - Performance: Often faster than synchronization
     * - Simplicity: Less code, fewer bugs
     * - Lock-free: No risk of deadlocks
     * 
     * COMMON ATOMIC TYPES:
     * - AtomicInteger: Thread-safe integer
     * - AtomicLong: Thread-safe long
     * - AtomicBoolean: Thread-safe boolean
     * - AtomicReference: Thread-safe object reference
     * 
     * ATOMIC METHODS:
     * - get(): Get current value
     * - set(newValue): Set new value
     * - incrementAndGet(): Increment and return new value
     * - compareAndSet(expected, new): Set only if current value equals expected
     */
    private static void atomicOperationsExample() {
        System.out.println("4. Atomic Operations:");
        System.out.println("   (5 threads incrementing atomic counter 1000 times each)");
        System.out.println("   (No synchronization needed - atomic operations are thread-safe!)\n");
        
        // Reset atomic counter to 0
        atomicCounter.set(0);
        
        // Create 5 threads that will increment the atomic counter
        Thread[] threads = new Thread[5];
        
        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            threads[i] = new Thread(() -> {
                // Each thread increments the counter 1000 times
                for (int j = 0; j < 1000; j++) {
                    // ===== ATOMIC OPERATION =====
                    // This operation is thread-safe by design!
                    // No synchronized block needed - the operation is atomic
                    atomicCounter.incrementAndGet();
                }
                System.out.println("Atomic Thread " + threadId + " completed");
            });
        }
        
        // Start all threads
        for (Thread thread : threads) {
            thread.start();
        }
        
        // Wait for all threads to complete
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        
        // Display the final result
        System.out.println("Final atomic counter value: " + atomicCounter.get());
        System.out.println("   (Should be exactly 5000 - atomic operations guarantee correctness)");
        System.out.println("Atomic operations example completed.\n");
    }
    
    /**
     * Example 5: Producer-Consumer Pattern
     * 
     * WHAT IS THE PRODUCER-CONSUMER PATTERN?
     * A classic synchronization pattern where:
     * - Producer threads create data and put it in a shared buffer
     * - Consumer threads take data from the buffer and process it
     * - The buffer has a limited size
     * 
     * THE CHALLENGE:
     * - Producer must wait when buffer is full
     * - Consumer must wait when buffer is empty
     * - Both must coordinate to avoid race conditions
     * 
     * THE SOLUTION: WAIT/NOTIFY MECHANISM
     * - wait(): Makes a thread wait until another thread calls notify()
     * - notify(): Wakes up one waiting thread
     * - notifyAll(): Wakes up all waiting threads
     * - Always use wait() in a while loop, not if statement!
     * 
     * REAL-WORLD EXAMPLES:
     * - Message queues
     * - Task queues
     * - Data processing pipelines
     * - Event handling systems
     */
    private static void producerConsumerExample() {
        System.out.println("5. Producer-Consumer Pattern:");
        System.out.println("   (Producer creates items, Consumer processes them)");
        System.out.println("   (Buffer can hold max " + MAX_SIZE + " items)\n");
        
        // Clear the shared list (our buffer)
        sharedList.clear();
        
        // ===== PRODUCER THREAD =====
        // Creates items and puts them in the buffer
        Thread producer = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                synchronized (sharedList) {
                    // ===== WAIT WHILE BUFFER IS FULL =====
                    // Use while loop, not if statement!
                    // This handles spurious wakeups and multiple producers
                    while (sharedList.size() >= MAX_SIZE) {
                        try {
                            System.out.println("Producer waiting - buffer full");
                            sharedList.wait();  // Wait until consumer removes an item
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            return;
                        }
                    }
                    // Buffer has space, add the item
                    sharedList.add(i);
                    System.out.println("Produced: " + i + " (buffer size: " + sharedList.size() + ")");
                    sharedList.notifyAll();  // Wake up any waiting consumers
                }
                // Simulate some work between productions
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
            System.out.println("Producer finished");
        });
        
        // ===== CONSUMER THREAD =====
        // Takes items from the buffer and processes them
        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                synchronized (sharedList) {
                    // ===== WAIT WHILE BUFFER IS EMPTY =====
                    while (sharedList.isEmpty()) {
                        try {
                            System.out.println("Consumer waiting - buffer empty");
                            sharedList.wait();  // Wait until producer adds an item
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            return;
                        }
                    }
                    // Buffer has items, take one
                    int value = sharedList.remove(0);
                    System.out.println("Consumed: " + value + " (buffer size: " + sharedList.size() + ")");
                    sharedList.notifyAll();  // Wake up any waiting producers
                }
                // Simulate some work between consumptions
                try {
                    Thread.sleep(150);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
            System.out.println("Consumer finished");
        });
        
        // Start both threads
        producer.start();
        consumer.start();
        
        // Wait for both threads to complete
        try {
            producer.join();
            consumer.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        System.out.println("Producer-Consumer example completed.\n");
    }
    
    /**
     * Example 6: CompletableFuture
     */
    private static void completableFutureExample() {
        System.out.println("6. CompletableFuture:");
        
        // Create a CompletableFuture
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
                return "Hello from CompletableFuture!";
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return "Interrupted";
            }
        });
        
        // Chain operations
        CompletableFuture<String> chainedFuture = future
            .thenApply(result -> result + " - Processed")
            .thenApply(String::toUpperCase)
            .thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " - Composed"));
        
        // Handle multiple futures
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Future 1");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Future 2");
        
        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> 
            result1 + " + " + result2);
        
        // Get results
        try {
            System.out.println("Chained result: " + chainedFuture.get());
            System.out.println("Combined result: " + combinedFuture.get());
        } catch (InterruptedException | ExecutionException e) {
            System.err.println("Error getting CompletableFuture result: " + e.getMessage());
        }
        
        System.out.println("CompletableFuture example completed.\n");
    }
    
    /**
     * Example of a custom thread-safe counter using ReentrantLock
     */
    static class ThreadSafeCounter {
        private int count = 0;
        private final ReentrantLock lock = new ReentrantLock();
        
        public void increment() {
            lock.lock();
            try {
                count++;
            } finally {
                lock.unlock();
            }
        }
        
        public int getCount() {
            lock.lock();
            try {
                return count;
            } finally {
                lock.unlock();
            }
        }
    }
    
    /**
     * Example of a custom thread that can be interrupted gracefully
     */
    static class InterruptibleThread extends Thread {
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // Do some work
                    System.out.println("Working...");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Thread interrupted, cleaning up...");
                    Thread.currentThread().interrupt();
                    break;
                }
            }
            System.out.println("Thread finished gracefully");
        }
    }
}