Race conditions and synchronized

class Counter {
    private int count = 0;
    void increment() { count++; }       // NOT atomic: read → add 1 → write
    int get() { return count; }
}

Counter c = new Counter();
Runnable task = () -> { for (int i = 0; i < 100_000; i++) c.increment(); };
Thread a = new Thread(task), b = new Thread(task);
a.start(); b.start(); a.join(); b.join();
System.out.println(c.get());   // expected 200000, often prints less, e.g. 137512

class SafeCounter {
    private int count = 0;
    synchronized void increment() { count++; }   // the lock is "this" object
    synchronized int get() { return count; }
}

class Inventory {
    private final Object lock = new Object();
    private int stock = 10;
    boolean reserve(int qty) {
        synchronized (lock) {                     // a synchronized block on a private lock
            if (stock < qty) return false;
            stock -= qty;                         // check-then-act happens as one unit
            return true;
        }
    }
}

class Worker implements Runnable {
    private volatile boolean running = true;   // without volatile, the loop might never see the change
    public void run() { while (running) { /* work */ } }
    public void stop() { running = false; }
}

void transfer(Account from, Account to, long paise) {
    Account first = from.id() < to.id() ? from : to;     // consistent order prevents deadlock
    Account second = first == from ? to : from;
    synchronized (first) {
        synchronized (second) {
            from.debit(paise);
            to.credit(paise);
        }
    }
}