public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Running in: " + Thread.currentThread().getName());
    }
}

// Usage — call start(), NOT run()
MyThread t = new MyThread();
t.start();  // spawns new thread, calls run() on it
// t.run()  ← DON'T: runs on current thread, no new thread created

public class MyTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Task running in: " + Thread.currentThread().getName());
    }
}

Thread t = new Thread(new MyTask());
t.start();

// Inline lambda — most common in modern code
Thread t1 = new Thread(() -> {
    System.out.println("Hello from thread: " + Thread.currentThread().getName());
});
t1.start();

// Named thread — helps with debugging
Thread t2 = new Thread(() -> System.out.println("Worker running"), "worker-1");
t2.start();

// Multiple threads running concurrently
for (int i = 0; i < 5; i++) {
    final int id = i;
    new Thread(() -> System.out.println("Thread " + id)).start();
}

Thread 2
Thread 0
Thread 4
Thread 1
Thread 3
// Order is non-deterministic — OS decides scheduling

Thread t = new Thread(() -> {
    Thread current = Thread.currentThread();
    System.out.println("Name: "     + current.getName());
    System.out.println("ID: "       + current.getId());
    System.out.println("Priority: " + current.getPriority());
    System.out.println("Daemon: "   + current.isDaemon());
}, "my-thread");

t.start();
t.join();  // wait for t to finish before continuing
System.out.println("Main thread continues");

// sleep — pause current thread for N milliseconds (TIMED_WAITING)
try {
    Thread.sleep(1000);  // sleep 1 second
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();  // restore interrupted status
}

// join — make current thread WAIT until another thread finishes
Thread worker = new Thread(() -> {
    System.out.println("Working...");
});
worker.start();
worker.join();  // main thread waits here until worker is TERMINATED
System.out.println("Worker done, continuing");

// interrupt — signal a thread to stop what it's doing
Thread t = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // do work...
    }
    System.out.println("Thread stopping gracefully");
});
t.start();
Thread.sleep(500);
t.interrupt();  // signal the thread to stop

public class Counter {
    private int count = 0;

    public void increment() {
        count++;  // looks like 1 operation — it's actually 3
    }

    public int getCount() { return count; }
}

Counter counter = new Counter();

// 1000 threads each increment once — expected result: 1000
List<Thread> threads = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    threads.add(new Thread(counter::increment));
}
threads.forEach(Thread::start);
threads.forEach(t -> { try { t.join(); } catch (InterruptedException e) {} });

System.out.println(counter.getCount());
// Expected: 1000. Actual: could be 947, 998, 1000 — unpredictable

public class SyncCounter {
    private int count = 0;

    // synchronized — only one thread at a time can call this
    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}
// Now 1000 threads → always 1000. Guaranteed.

public class BankAccount {
    private double balance;
    private final Object lock = new Object();  // dedicated lock object

    public void deposit(double amount) {
        // non-critical code can run without lock
        if (amount <= 0) throw new IllegalArgumentException("Invalid amount");

        synchronized (lock) {   // acquire lock
            balance += amount;   // critical section
        }                        // release lock automatically
    }

    public void withdraw(double amount) {
        synchronized (lock) {
            if (balance < amount) throw new IllegalStateException("Insufficient funds");
            balance -= amount;
        }
    }

    public synchronized double getBalance() { return balance; }
}

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
    private final AtomicInteger count = new AtomicInteger(0);

    public void increment() { count.incrementAndGet(); }
    public int  getCount()   { return count.get(); }
}
// No synchronized keyword needed. Always correct. Faster for high contention.

// Other useful operations:
AtomicInteger ai = new AtomicInteger(10);
ai.getAndIncrement();   // returns 10, then increments to 11
ai.incrementAndGet();   // increments to 12, returns 12
ai.addAndGet(5);        // adds 5, returns 17
ai.compareAndSet(17, 0); // if value is 17, set to 0 — atomic swap

// Problem 1: Thread creation is expensive
// Creating 10,000 threads for 10,000 tasks burns memory and CPU
for (Request req : requests) {
    new Thread(() -> handle(req)).start();  // ❌ new OS thread per request
}

// Problem 2: No return values
// Thread.run() is void — you can't get a result back easily

// Problem 3: No lifecycle management
// No built-in way to wait for all tasks, handle errors, or shut down cleanly

import java.util.concurrent.*;

// Create a pool of 4 threads
ExecutorService executor = Executors.newFixedThreadPool(4);

// Submit 10 tasks — pool handles scheduling
for (int i = 0; i < 10; i++) {
    final int taskId = i;
    executor.submit(() -> {
        System.out.printf("Task %d on %s%n", taskId,
            Thread.currentThread().getName());
    });
}

// Shutdown: no new tasks accepted, existing tasks complete
executor.shutdown();

// Wait up to 10s for all tasks to finish
if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
    executor.shutdownNow();  // force stop if still running
}

int cores = Runtime.getRuntime().availableProcessors();
ExecutorService pool = Executors.newFixedThreadPool(cores);

List<String> urls = List.of("url1", "url2", "url3", "url4", "url5");

for (String url : urls) {
    pool.submit(() -> {
        System.out.println("Fetching: " + url + " on "
            + Thread.currentThread().getName());
        // simulate network call
        Thread.sleep(100);
    });
}

pool.shutdown();
pool.awaitTermination(30, TimeUnit.SECONDS);

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

// Run once after 2 second delay
scheduler.schedule(() -> System.out.println("Delayed task"),
    2, TimeUnit.SECONDS);

// Run every 5 seconds after initial 1 second delay
scheduler.scheduleAtFixedRate(() -> {
    System.out.println("Heartbeat: " + System.currentTimeMillis());
}, 1, 5, TimeUnit.SECONDS);

// Let it run for 20 seconds then shut down
Thread.sleep(20_000);
scheduler.shutdown();

import java.util.concurrent.*;

ExecutorService pool = Executors.newFixedThreadPool(3);

// Callable — returns a value
Callable<Integer> task = () -> {
    Thread.sleep(500);       // simulate work
    return 42;               // return the result
};

// submit() returns a Future — a promise of a result
Future<Integer> future = pool.submit(task);

// Do other work while task runs in background...
System.out.println("Task submitted, doing other work");

// When you need the result, call get() — blocks until ready
Integer result = future.get();  // blocks here if task not yet done
System.out.println("Result: " + result);  // Result: 42

pool.shutdown();

Future<String> f = pool.submit(() -> "hello");

// isDone() — non-blocking check
if (f.isDone()) {
    System.out.println("Already done: " + f.get());
}

// get() with timeout — don't wait forever
try {
    String result = f.get(2, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    System.out.println("Task took too long!");
    f.cancel(true);  // interrupt the task
} catch (ExecutionException e) {
    // Task threw an exception — wrapped in ExecutionException
    System.out.println("Task failed: " + e.getCause().getMessage());
}

List<Callable<Integer>> tasks = List.of(
    () -> computeExpensiveResult(1),
    () -> computeExpensiveResult(2),
    () -> computeExpensiveResult(3)
);

// Submit all, wait for all to complete
List<Future<Integer>> futures = pool.invokeAll(tasks);

// Collect results
for (Future<Integer> future : futures) {
    System.out.println("Result: " + future.get());
}

ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> System.out.println("done"));
// ❌ No shutdown() — pool threads are non-daemon, JVM hangs forever

ExecutorService pool = Executors.newFixedThreadPool(4);
try {
    pool.submit(() -> System.out.println("done"));
} finally {
    pool.shutdown();  // always in finally block
}

Object lock1 = new Object();
Object lock2 = new Object();

Thread t1 = new Thread(() -> {
    synchronized(lock1) {
        Thread.sleep(50);
        synchronized(lock2) { /* ... */ }  // waits for lock2
    }
});

Thread t2 = new Thread(() -> {
    synchronized(lock2) {
        Thread.sleep(50);
        synchronized(lock1) { /* ... */ }  // waits for lock1 ← DEADLOCK
    }
});
// Fix: always acquire locks in the same order in every thread

Future<String> f = pool.submit(() -> riskyNetworkCall());
String result = f.get();  // ❌ hangs if network never responds