Blocking I/O Inside Sync Blocks — Thread Management Killer

import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;

public class ProcessInspector {

    public static void main(String[] args) {

        // The JVM exposes the current process's info through the Runtime bean
        RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean();

        // getPid() is available from Java 9+. It returns this process's OS-level PID.
        long currentPid = ProcessHandle.current().pid();

        // How long has this JVM process been alive in milliseconds?
        long uptimeMs = runtimeBean.getUptime();

        System.out.println("=== Current JVM Process Info ===");
        System.out.println("Process ID (PID)    : " + currentPid);
        System.out.println("JVM Name            : " + runtimeBean.getVmName());
        System.out.println("Process Uptime (ms) : " + uptimeMs);

        // Now let's SPAWN a child process — a completely separate OS process.
        // We'll run the 'java -version' command as its own isolated process.
        System.out.println("\n=== Spawning a Child Process ===");
        try {
            ProcessBuilder processBuilder = new ProcessBuilder("java", "-version");

            // Redirect stderr to stdout so we can read the version output easily
            processBuilder.redirectErrorStream(true);

            Process childProcess = processBuilder.start();

            // Read the child process's output stream
            String output = new String(childProcess.getInputStream().readAllBytes());

            // waitFor() BLOCKS the current thread until the child process terminates
            int exitCode = childProcess.waitFor();

            System.out.println("Child process output : " + output.strip());
            System.out.println("Child exit code      : " + exitCode);
            // Exit code 0 = success. Non-zero = something went wrong.

            // The child has its own PID, separate memory space, and lifecycle
            System.out.println("Child PID            : " + childProcess.pid());
            System.out.println("Parent PID           : " + currentPid);

        } catch (Exception ex) {
            System.err.println("Failed to spawn child process: " + ex.getMessage());
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadLifecycleDemo {

    // AtomicInteger is thread-safe. A plain int here would be a data race.
    // We'll demonstrate BOTH to show the difference.
    private static AtomicInteger safeCounter = new AtomicInteger(0);
    private static int unsafeCounter = 0; // <-- this WILL misbehave under concurrency

    public static void main(String[] args) throws InterruptedException {

        System.out.println("Main thread PID  : " + ProcessHandle.current().pid());
        System.out.println("Main thread ID   : " + Thread.currentThread().threadId());
        System.out.println("Main thread name : " + Thread.currentThread().getName());

        // --- Creating threads via Runnable (preferred over extending Thread) ---
        // Runnable separates the TASK from the execution mechanism.
        Runnable incrementTask = () -> {
            for (int i = 0; i < 1000; i++) {
                safeCounter.incrementAndGet();  // atomic: read-modify-write as one operation
                unsafeCounter++;                // NOT atomic: read, then modify, then write separately
            }
            System.out.println("Thread " + Thread.currentThread().getName()
                + " finished. Safe counter now: " + safeCounter.get());
        };

        // Spawn 5 threads all running the same task
        Thread[] workers = new Thread[5];
        for (int i = 0; i < workers.length; i++) {
            workers[i] = new Thread(incrementTask, "Worker-" + (i + 1));
        }

        // Start all threads — OS scheduler decides the actual execution order
        System.out.println("\nLaunching 5 worker threads...");
        for (Thread worker : workers) {
            worker.start(); // Moves thread from NEW state to RUNNABLE state
        }

        // join() blocks main thread until each worker finishes.
        // Without join(), main might print results before workers are done.
        for (Thread worker : workers) {
            worker.join();
        }

        System.out.println("\n=== Final Results (5 threads x 1000 increments = 5000 expected) ===");
        System.out.println("Safe counter   : " + safeCounter.get());   // Always 5000
        System.out.println("Unsafe counter : " + unsafeCounter);        // Probably NOT 5000
    }
}

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.Executors;

public class VirtualThreadDemo {

    // Simulates a blocking I/O operation (like a database query or HTTP call)
    private static void simulateDatabaseQuery(int queryId) throws InterruptedException {
        // Thread.sleep() voluntarily yields the thread back to the scheduler.
        // With virtual threads, this PARKS the virtual thread (frees the carrier OS thread)
        // rather than blocking a real OS thread.
        Thread.sleep(50); // pretend this is a 50ms DB round-trip
        System.out.println("Query " + queryId + " complete on: " + Thread.currentThread());
    }

    public static void main(String[] args) throws InterruptedException {

        int numberOfTasks = 500; // try this with platform threads and watch it crawl

        // --- Approach 1: Traditional platform (OS) threads ---
        Instant platformStart = Instant.now();
        try (var platformExecutor = Executors.newFixedThreadPool(50)) {
            // Fixed pool of 50 OS threads handling 500 tasks.
            // At any moment, 450 tasks are waiting in the queue.
            for (int i = 1; i <= numberOfTasks; i++) {
                final int taskId = i;
                platformExecutor.submit(() -> {
                    try { simulateDatabaseQuery(taskId); }
                    catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                });
            }
        } // executor.close() waits for all tasks to finish (Java 19+ AutoCloseable)
        long platformMs = Duration.between(platformStart, Instant.now()).toMillis();

        // --- Approach 2: Virtual threads (Java 21+) ---
        Instant virtualStart = Instant.now();
        try (var virtualExecutor = Executors.newVirtualThreadPerTaskExecutor()) {
            // Creates a NEW virtual thread per task — sounds expensive, but virtual
            // threads are so cheap (~1KB stack) the JVM creates them without hesitation.
            for (int i = 1; i <= numberOfTasks; i++) {
                final int taskId = i;
                virtualExecutor.submit(() -> {
                    try { simulateDatabaseQuery(taskId); }
                    catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                });
            }
        }
        long virtualMs = Duration.between(virtualStart, Instant.now()).toMillis();

        System.out.println("\n=== Throughput Comparison: 500 tasks, each with 50ms I/O ===");
        System.out.println("Platform threads (pool of 50) : " + platformMs + " ms");
        System.out.println("Virtual threads               : " + virtualMs  + " ms");
        System.out.println("Speedup factor                : ~" + (platformMs / Math.max(virtualMs, 1)) + "x");
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockPreventionDemo {

    // Two shared resources — imagine these are bank accounts
    private static final Lock accountAlpha = new ReentrantLock();
    private static final Lock accountBeta  = new ReentrantLock();

    // DEADLOCK-PRONE version: each thread acquires locks in OPPOSITE order
    static void transferDeadlockProne(String threadName, boolean reverseOrder)
            throws InterruptedException {
        Lock firstLock  = reverseOrder ? accountBeta  : accountAlpha;
        Lock secondLock = reverseOrder ? accountAlpha : accountBeta;

        firstLock.lock();
        System.out.println(threadName + " acquired first lock, waiting for second...");
        Thread.sleep(50); // makes the race window obvious in demos
        secondLock.lock();
        try {
            System.out.println(threadName + " transferred funds (deadlock-prone path)");
        } finally {
            secondLock.unlock();
            firstLock.unlock();
        }
    }

    // SAFE version: both threads ALWAYS acquire locks in the same order (alpha → beta)
    static void transferSafe(String threadName) throws InterruptedException {
        // Consistent global ordering: always lock accountAlpha before accountBeta.
        // No matter how many threads call this, circular wait is impossible.
        accountAlpha.lock();
        try {
            System.out.println(threadName + " acquired alpha lock");
            Thread.sleep(20);
            accountBeta.lock();
            try {
                System.out.println(threadName + " acquired beta lock — transfer complete!");
            } finally {
                accountBeta.unlock();
            }
        } finally {
            accountAlpha.unlock(); // always unlock in reverse order of acquisition
        }
    }

    public static void main(String[] args) throws InterruptedException {

        System.out.println("=== Safe Transfer Demo (consistent lock ordering) ===");

        Thread sender   = new Thread(() -> {
            try { transferSafe("Sender");   }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        }, "Sender");

        Thread receiver = new Thread(() -> {
            try { transferSafe("Receiver"); }
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        }, "Receiver");

        sender.start();
        receiver.start();
        sender.join();
        receiver.join();

        System.out.println("Both transfers completed. No deadlock.");

        // To observe the current thread state programmatically:
        Thread monitorThread = new Thread(() -> {
            try { Thread.sleep(1000); } // TIMED_WAITING during sleep
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        }, "MonitorThread");

        monitorThread.start();
        Thread.sleep(10); // let monitorThread enter sleep before we check
        System.out.println("\nMonitorThread state: " + monitorThread.getState()); // TIMED_WAITING
        monitorThread.join();
        System.out.println("MonitorThread state: " + monitorThread.getState()); // TERMINATED
    }
}

import java.util.concurrent.CountDownLatch;

public class ContextSwitchSimulator {

    private static final int NUM_PROCESSES = 100;
    private static final int WORK_UNITS = 100_000;

    public static void main(String[] args) throws InterruptedException {

        long start = System.nanoTime();
        CountDownLatch latch = new CountDownLatch(NUM_PROCESSES);

        // Simulate many processes by spawning many threads (each thread = one process-like workload)
        for (int i = 0; i < NUM_PROCESSES; i++) {
            final int id = i;
            new Thread(() -> {
                // Simulate CPU work: busy spin
                long sum = 0;
                for (int j = 0; j < WORK_UNITS; j++) {
                    sum += j * (id & 7); // artificial work
                }
                latch.countDown();
            }).start();
        }

        latch.await(); // wait for all threads
        long elapsed = System.nanoTime() - start;
        System.out.println(NUM_PROCESSES + " threads completed " + WORK_UNITS + " units each in " 
            + elapsed / 1_000_000 + " ms");
        System.out.println("Average context switch overhead per thread: ~" 
            + (elapsed / NUM_PROCESSES / 1000) + " μs (rough estimate)");
        // In reality, the OS schedules threads on available cores; context switch overhead is baked in.
    }
}