Multithreading Basics

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // A Runnable is just "a task to run" — one method, run().
        // The lambda below IS the task; nothing runs yet.
        Runnable greet = () -> System.out.println("  Hello from the new thread!");

        // Wrap the task in a Thread and start it.
        Thread t = new Thread(greet);

        System.out.println("State before start: " + t.getState());  // NEW
        t.start();              // start() spins up a NEW thread, then runs the task
        System.out.println("Main thread keeps going...");

        // join() makes main WAIT here until t has finished.
        t.join();
        System.out.println("State after join:  " + t.getState());    // TERMINATED
        System.out.println("Done.");
    }
}

State before start: NEW
Main thread keeps going...
  Hello from the new thread!
State after join:  TERMINATED
Done.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 🎯 YOUR TURN — fill in the blanks marked with ___

        // 1) Make a Runnable task that prints "Task running!"
        Runnable task = () -> System.out.println("Task running!");

        // 2) Wrap the task in a Thread called "t"
        Thread t = new ___(task);      // 👉 which class wraps a Runnable?

        // 3) Actually START the thread (NOT run()!)
        t.___();                       // 👉 the method that spawns a new thread

        // 4) Wait for the thread to finish before printing "Done"
        t.___();                       // 👉 the method that blocks until t ends

        System.out.println("Done");

        // ✅ Expected output:
        // Task running!
        // Done
    }
}

Task running!
Done

public class Main {
    static int counter = 0;            // shared state — both threads touch it
    static int safeCounter = 0;        // protected by synchronized below

    // synchronized = only ONE thread inside this method at a time.
    static synchronized void bumpSafe() { safeCounter++; }

    public static void main(String[] args) throws InterruptedException {
        // counter++ is really 3 steps: read, add 1, write back.
        // Two threads can read the SAME value, so increments get lost.
        Runnable unsafe = () -> {
            for (int i = 0; i < 100_000; i++) counter++;   // RACE CONDITION
        };
        Runnable safe = () -> {
            for (int i = 0; i < 100_000; i++) bumpSafe();   // locked, correct
        };

        Thread a = new Thread(unsafe), b = new Thread(unsafe);
        a.start(); b.start();
        a.join();  b.join();        // wait for both before reading the result

        Thread c = new Thread(safe), d = new Thread(safe);
        c.start(); d.start();
        c.join();  d.join();

        // Unsafe is usually LESS than 200000 (and changes each run).
        System.out.println("Unsafe counter: " + counter + " (wanted 200000)");
        System.out.println("Safe counter:   " + safeCounter + " (always 200000)");
    }
}

Unsafe counter: 138472 (wanted 200000)
Safe counter:   200000 (always 200000)

public class Main {
    static int total = 0;

    // 🎯 YOUR TURN — fill in the blanks marked with ___

    // 1) Add the keyword that lets only ONE thread in at a time
    static ___ void add() {            // 👉 the lock keyword
        total++;
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable job = () -> {
            for (int i = 0; i < 50_000; i++) add();
        };
        Thread a = new Thread(job), b = new Thread(job);
        a.start(); b.start();

        // 2) Wait for BOTH threads before reading total
        a.___();                       // 👉 block until a finishes
        b.___();                       // 👉 block until b finishes

        System.out.println("Total: " + total);

        // ✅ Expected output:
        // Total: 100000
    }
}

Total: 100000

public class Main {
    // volatile = "always read/write the real value in main memory,
    // never a stale per-thread cache". One writer, many readers.
    static volatile boolean ready = false;

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();   // the object we coordinate on

        Thread worker = new Thread(() -> {
            synchronized (lock) {
                // wait() RELEASES the lock and sleeps until notified.
                while (!ready) {
                    try { lock.wait(); } catch (InterruptedException e) { return; }
                }
            }
            System.out.println("  Worker: got the signal, working now.");
        });
        worker.start();

        Thread.sleep(100);            // let the worker reach wait()
        System.out.println("Main: sending the signal.");
        synchronized (lock) {
            ready = true;
            lock.notify();            // wake one waiting thread
        }
        worker.join();
        System.out.println("Main: worker finished.");
    }
}

Main: sending the signal.
  Worker: got the signal, working now.
Main: worker finished.

public class Main {
    // 🎯 MINI-CHALLENGE: count to a million with two threads, safely
    // 1. Make a shared "static int count = 0;"
    // 2. Write a synchronized method that does count++
    // 3. In main, create TWO threads; each calls that method 500_000 times in a loop
    // 4. start() both, then join() both
    // 5. Print: "Final count: " + count
    //
    // ✅ Expected output:
    // Final count: 1000000

    public static void main(String[] args) throws InterruptedException {
        // your code here
    }
}