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.
    }
}

// io.thecodeforge
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void* compute_hash(void* arg) {
    int id = *(int*)arg;
    printf("Thread %d starting work\n", id);
    free(arg);
    return (void*)(long)(id * 2);
}

int main() {
    pthread_t threads[3];
    int* ids[3];
    
    for (int i = 0; i < 3; i++) {
        ids[i] = malloc(sizeof(int));
        *ids[i] = i;
        if (pthread_create(&threads[i], NULL, compute_hash, ids[i]) != 0) {
            perror("Failed to create thread");
            exit(1);
        }
    }
    
    for (int i = 0; i < 3; i++) {
        void* ret;
        pthread_join(threads[i], &ret);
        printf("Thread %d returned %ld\n", i, (long)ret);
    }
    
    return 0;
}

// io.thecodeforge
#include <pthread.h>
#include <stdio.h>

#define ITERATIONS 1000000

int shared_counter = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void* increment(void* arg) {
    for (int i = 0; i < ITERATIONS; i++) {
        pthread_mutex_lock(&lock);
        shared_counter++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    
    pthread_create(&t1, NULL, increment, NULL);
    pthread_create(&t2, NULL, increment, NULL);
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    
    printf("Final counter: %d (expected %d)\n", 
           shared_counter, 2 * ITERATIONS);
    
    pthread_mutex_destroy(&lock);
    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void* thread_func(void* arg) {
    printf("Thread running\n");
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);
    pthread_join(tid, NULL);
    printf("Process main\n");
    return 0;
}

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <pthread.h>

void* worker(void* arg) {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(0, &cpuset); // pin to CPU 0
    pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
    printf("Thread pinned to CPU 0\n");
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, worker, NULL);
    pthread_join(tid, NULL);
    return 0;
}

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int child_func(void* arg) {
    printf("Child in new PID namespace, PID: %d\n", getpid());
    return 0;
}

int main() {
    char stack[1024*1024];
    pid_t pid = clone(child_func, stack + sizeof(stack), CLONE_NEWPID | SIGCHLD, NULL);
    if (pid == -1) { perror("clone"); return 1; }
    waitpid(pid, NULL, 0);
    return 0;
}