Java Synchronization Deep Dive — Locks, Monitors and Memory Visibility

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Demonstrates the real cost of monitor contention.
 * Run this and compare the timing between the contended
 * and uncontended scenarios to see the fat-lock overhead.
 */
public class MonitorLockDemo {

    // Shared counter — this is our 'bathroom everyone wants to use'
    private int ticketsSold = 0;

    // The synchronized method — one thread at a time enters this 'room'
    public synchronized void sellTicket() {
        // Everything inside here is protected by 'this' object's monitor.
        // The JVM ensures mutual exclusion across all threads calling this method.
        ticketsSold++;
    }

    public int getTicketsSold() {
        return ticketsSold; // Safe to read here; we're done with concurrent writes
    }

    public static void main(String[] args) throws InterruptedException {
        MonitorLockDemo box = new MonitorLockDemo();
        int threadCount = 10;
        int salesPerThread = 100_000;

        ExecutorService pool = Executors.newFixedThreadPool(threadCount);
        // CountDownLatch lets us wait for ALL threads to finish before reading results
        CountDownLatch allDone = new CountDownLatch(threadCount);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < threadCount; i++) {
            pool.submit(() -> {
                for (int sale = 0; sale < salesPerThread; sale++) {
                    box.sellTicket(); // Each call must acquire and release the monitor
                }
                allDone.countDown(); // Signal: this thread finished its work
            });
        }

        allDone.await(); // Block main thread until all seller threads are done
        long elapsed = System.currentTimeMillis() - startTime;

        System.out.println("Expected tickets sold : " + (threadCount * salesPerThread));
        System.out.println("Actual tickets sold   : " + box.getTicketsSold());
        System.out.println("Time taken            : " + elapsed + "ms");
        // Without synchronization, 'actual' would be LESS than 'expected'
        // because threads would overwrite each other's increments

        pool.shutdown();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * Proves that volatile does NOT fix compound-action race conditions.
 * The check-then-act pattern is unsafe even with volatile.
 */
public class VolatileVsSynchronized {

    // volatile ensures visibility: every thread sees the latest value.
    // But it does NOT make the increment operation atomic!
    private volatile int volatileCounter = 0;

    // This is the correct tool for atomic compound actions
    private int synchronizedCounter = 0;

    // WRONG: looks safe, isn't. The read and write are two separate operations.
    // Between the read and write, another thread can swoop in and also read the
    // old value, causing both threads to write the same incremented value — a lost update.
    public void unsafeIncrement() {
        volatileCounter++; // This compiles to: READ volatileCounter, ADD 1, WRITE back
                           // Three steps — not atomic even with volatile!
    }

    // RIGHT: synchronized turns the entire read-modify-write into one atomic operation.
    // No other thread can enter while we're inside here.
    public synchronized void safeIncrement() {
        synchronizedCounter++;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileVsSynchronized demo = new VolatileVsSynchronized();
        ExecutorService pool = Executors.newFixedThreadPool(8);
        int iterations = 50_000;

        for (int i = 0; i < 8; i++) {
            pool.submit(() -> {
                for (int j = 0; j < iterations; j++) {
                    demo.unsafeIncrement();
                    demo.safeIncrement();
                }
            });
        }

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

        int expected = 8 * iterations;
        System.out.println("Expected count             : " + expected);
        // volatile counter will almost certainly be LESS than expected
        // because increments were lost in concurrent reads
        System.out.println("volatile counter (UNSAFE)  : " + demo.volatileCounter);
        // synchronized counter will always equal expected
        System.out.println("synchronized counter (SAFE): " + demo.synchronizedCounter);

        boolean volatileFailed = demo.volatileCounter < expected;
        System.out.println("\nvolatile lost updates      : " + volatileFailed);
    }
}

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * A bounded queue where producers wait when full and consumers wait when empty.
 * This is the classic producer-consumer problem solved correctly with
 * ReentrantLock and Condition variables — two named signals instead of one
 * generic monitor. This is cleaner and more efficient than wait/notifyAll.
 */
public class BoundedTicketQueue {

    private final Queue<String> tickets = new ArrayDeque<>();
    private final int maxCapacity;
    private final ReentrantLock lock = new ReentrantLock();

    // Two distinct Conditions on the SAME lock — this is the key advantage
    // over synchronized + wait/notify where you only have one monitor signal
    private final Condition notFull  = lock.newCondition(); // producers wait here
    private final Condition notEmpty = lock.newCondition(); // consumers wait here

    public BoundedTicketQueue(int maxCapacity) {
        this.maxCapacity = maxCapacity;
    }

    public void produce(String ticket) throws InterruptedException {
        lock.lock(); // Acquire the lock explicitly — must ALWAYS pair with unlock()
        try {
            // While the queue is full, make the producer wait on the 'notFull' condition.
            // await() atomically releases the lock and suspends the thread.
            while (tickets.size() == maxCapacity) {
                System.out.println(Thread.currentThread().getName()
                        + " waiting — queue full");
                notFull.await();
            }
            tickets.offer(ticket);
            System.out.println(Thread.currentThread().getName()
                    + " produced: " + ticket + " | Queue size: " + tickets.size());
            // Signal ONLY the consumers — not producers.
            // This is impossible with a single notify(); you'd have to use notifyAll()
            // and wake everyone up unnecessarily.
            notEmpty.signal();
        } finally {
            lock.unlock(); // ALWAYS in finally — even if an exception is thrown
        }
    }

    public String consume() throws InterruptedException {
        lock.lock();
        try {
            while (tickets.isEmpty()) {
                System.out.println(Thread.currentThread().getName()
                        + " waiting — queue empty");
                notEmpty.await();
            }
            String ticket = tickets.poll();
            System.out.println(Thread.currentThread().getName()
                    + " consumed: " + ticket + " | Queue size: " + tickets.size());
            notFull.signal(); // Wake up a waiting producer
            return ticket;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        BoundedTicketQueue queue = new BoundedTicketQueue(3);

        Thread producer = new Thread(() -> {
            String[] events = {"Concert-A", "Concert-B", "Concert-C", "Concert-D", "Concert-E"};
            for (String event : events) {
                try {
                    queue.produce(event);
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "TicketProducer");

        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    queue.consume();
                    Thread.sleep(150); // Consumer is slower — will cause producer to wait
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "TicketConsumer");

        producer.start();
        consumer.start();
    }
}

import java.util.concurrent.locks.ReentrantLock;

/**
 * Shows the deadlock-prone pattern and then fixes it with lock ordering.
 * Run the 'unsafe' transfer method and you'll see a hang.
 * The 'safe' transfer uses System.identityHashCode to enforce consistent lock order.
 */
public class DeadlockPrevention {

    static class BankAccount {
        private final String owner;
        private double balance;
        private final ReentrantLock lock = new ReentrantLock();

        BankAccount(String owner, double initialBalance) {
            this.owner = owner;
            this.balance = initialBalance;
        }

        // Package-private intentionally — only used inside transfer logic
        ReentrantLock getLock() { return lock; }
        String getOwner()      { return owner; }
        double getBalance()    { return balance; }
        void debit(double amount)  { balance -= amount; }
        void credit(double amount) { balance += amount; }
    }

    /**
     * UNSAFE: Thread 1 locks Alice then waits for Bob.
     *         Thread 2 locks Bob then waits for Alice.
     *         Classic deadlock.
     */
    public static void unsafeTransfer(BankAccount from, BankAccount to, double amount)
            throws InterruptedException {
        from.getLock().lock();
        try {
            Thread.sleep(50); // Simulates real work; makes deadlock near-certain
            to.getLock().lock(); // May block forever if 'to' is locked by another thread
            try {
                from.debit(amount);
                to.credit(amount);
                System.out.println("UNSAFE Transfer: " + from.getOwner()
                        + " -> " + to.getOwner() + " £" + amount);
            } finally {
                to.getLock().unlock();
            }
        } finally {
            from.getLock().unlock();
        }
    }

    /**
     * SAFE: Always acquire locks in identity hash code order.
     * Both threads agree on which lock comes first — circular wait is impossible.
     * System.identityHashCode gives a stable ordering that doesn't depend on
     * business logic — works even with equal objects.
     */
    public static void safeTransfer(BankAccount accountA, BankAccount accountB, double amount) {
        // Determine lock acquisition order by a stable, consistent key
        int hashA = System.identityHashCode(accountA);
        int hashB = System.identityHashCode(accountB);

        ReentrantLock firstLock  = (hashA <= hashB) ? accountA.getLock() : accountB.getLock();
        ReentrantLock secondLock = (hashA <= hashB) ? accountB.getLock() : accountA.getLock();

        firstLock.lock();
        try {
            secondLock.lock();
            try {
                accountA.debit(amount);
                accountB.credit(amount);
                System.out.println("SAFE Transfer: " + accountA.getOwner()
                        + " -> " + accountB.getOwner() + " £" + amount);
            } finally {
                secondLock.unlock();
            }
        } finally {
            firstLock.unlock();
        }
    }

    public static void main(String[] args) {
        BankAccount alice = new BankAccount("Alice", 1000.0);
        BankAccount bob   = new BankAccount("Bob",   1000.0);

        System.out.println("--- Running SAFE transfers (no deadlock) ---");
        // Thread 1: Alice -> Bob
        Thread t1 = new Thread(() -> safeTransfer(alice, bob, 100.0), "TransferThread-1");
        // Thread 2: Bob -> Alice (reverse direction — safe version handles this)
        Thread t2 = new Thread(() -> safeTransfer(bob, alice, 50.0),  "TransferThread-2");

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("Alice final balance: £" + alice.getBalance());
        System.out.println("Bob final balance  : £" + bob.getBalance());
    }
}