Concurrency Basics

// 1. Runnable as a lambda (preferred) -- hand the task to a Thread
Thread t1 = new Thread(() -> System.out.println("run by " + Thread.currentThread().getName()));

// 2. subclass Thread (rare -- only when you must override more than run())
class Worker extends Thread {
    @Override public void run() { System.out.println("working"); }
}

// 3. Callable -- needs an ExecutorService to run it (see High-Level Concurrency)
Callable<Integer> job = () -> 6 * 7;

Thread t = new Thread(() -> System.out.println(Thread.currentThread().getName()));
t.start();     // "Thread-0" -- runs on a new thread
t.run();       // "main"     -- ordinary method call, no new thread
t.start();     // IllegalThreadStateException -- a thread starts exactly once

var squares = new int[3];
var workers = new Thread[3];
for (int i = 0; i < 3; i++) {
    int idx = i;
    workers[i] = new Thread(() -> squares[idx] = idx * idx);
    workers[i].start();
}
for (Thread w : workers) {
    w.join();          // wait for each worker to terminate
}
// every write in a worker happens-before the join() that saw it end -> safe to read now
System.out.println(java.util.Arrays.toString(squares));   // [0, 1, 4]

Runnable pollLoop = () -> {
    while (!Thread.currentThread().isInterrupted()) {
        // ... one CPU-bound step ...
    }
    System.out.println("stopped cleanly");
};

Runnable blockingLoop = () -> {
    try {
        while (true) {
            Thread.sleep(1000);        // wakes early by throwing if interrupted
            // ... periodic work ...
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();   // restore the flag, then return
    }
};

Thread t = new Thread(blockingLoop);
t.start();
t.interrupt();     // asks t to stop; its sleep() throws InterruptedException

class Counter {
    private long count;                          // guarded by 'this'

    synchronized void increment() { count++; }   // locks 'this' for the body
    synchronized long get() { return count; }
}

class BankAccount {
    private final Object lock = new Object();     // private -- outsiders cannot grab it
    private long cents;

    void deposit(long amount) {
        synchronized (lock) {                     // block form: narrow, explicit target
            cents += amount;
        }
    }
}

class Registry {
    private static int nextId;
    static synchronized int allocate() { return nextId++; }   // locks the Class object
}

class BlockingBox<T> {
    private T value;

    synchronized void put(T v) throws InterruptedException {
        while (value != null) {
            wait();                 // release the lock; wait for a take()
        }
        value = v;
        notifyAll();                // wake any waiting take()
    }

    synchronized T take() throws InterruptedException {
        while (value == null) {
            wait();
        }
        T v = value;
        value = null;
        notifyAll();
        return v;
    }
}

class Worker implements Runnable {
    private volatile boolean running = true;   // without volatile the reader may loop forever

    void stop() { running = false; }

    public void run() {
        while (running) {
            // ... work ...
        }
    }
}

// volatile is NOT enough for this -- ++ is read-modify-write:
// volatile int hits;  two threads doing hits++ still lose updates.
// use AtomicInteger, or synchronized.

// DEADLOCK: transfer(a, b) and transfer(b, a) running at once
void transfer(Account from, Account to, long amount) {
    synchronized (from) {
        synchronized (to) {
            from.debit(amount);
            to.credit(amount);
        }
    }
}

// FIX: lock the lower account id first, so every caller agrees on the order
void transfer(Account from, Account to, long amount) {
    Account first  = from.id() < to.id() ? from : to;
    Account second = from.id() < to.id() ? to : from;
    synchronized (first) {
        synchronized (second) {
            from.debit(amount);
            to.credit(amount);
        }
    }
}