Locks in Java — The Complete Story

public class BookingService {
    private int availableSeats = 200;

    public String bookTicket(String userId) {
        if (availableSeats > 0) {
            availableSeats--;
            return "Booking confirmed for " + userId;
        }
        return "Housefull! No seats available";
    }
}

public class BookingService {
    private int availableSeats = 200;

    public synchronized String bookTicket(String userId) {
        if (availableSeats > 0) {
            availableSeats--;
            return "Booking confirmed for " + userId + " | Seats left: " + availableSeats;
        }
        return "Housefull!";
    }
}

// 1. Synchronized method — the lock is 'this' object
public synchronized void bookTicket() {
    // only one thread per BookingService instance
}

// 2. Synchronized block — you pick the lock object (more precise)
public void bookTicket() {
    synchronized (this) {
        // same as above, but you can lock just the critical part
    }
}

// 3. Static synchronized — the lock is the Class object itself
public static synchronized void loadShowTimings() {
    // only one thread across ALL instances of BookingService
}

public class BookingService {

    // BAD — Priya's first attempt: entire method locked
    public synchronized String processBooking(BookingRequest request) {
        User user = validateUser(request.getUserId());    // 50ms — calls auth service
        Show show = fetchShowDetails(request.getShowId()); // 100ms — calls movie DB
        Seat seat = selectBestSeat(show);                  // 5ms — CPU work
        confirmBooking(user, seat);                        // 2ms — THE ONLY PART THAT NEEDS A LOCK
        sendConfirmationEmail(user);                       // 200ms — calls email service
        return "Booked!";
    }
    // Total: 357ms locked. Next user waits 357ms even though only 2ms needs protection!
}

public class BookingService {

    // GOOD — only lock the 2ms critical section
    public String processBooking(BookingRequest request) {
        User user = validateUser(request.getUserId());      // no lock needed
        Show show = fetchShowDetails(request.getShowId());   // no lock needed
        Seat seat;
        synchronized (this) {
            seat = selectBestSeat(show);                     // lock for 7ms total
            confirmBooking(user, seat);
        }
        sendConfirmationEmail(user);                         // no lock needed
        return "Booked!";
    }
    // 50,000 users now only wait for the 7ms critical section, not 357ms
}

public class FlashDealService {
    private int freePopcornLeft = 50;
    private final ReentrantLock lock = new ReentrantLock();

    public String claimDeal(String userId) {
        try {
            // Try for 2 seconds. If too many people ahead, give up gracefully.
            if (lock.tryLock(2, TimeUnit.SECONDS)) {
                try {
                    if (freePopcornLeft > 0) {
                        freePopcornLeft--;
                        return "🍿 Free popcorn claimed, " + userId + "! " + freePopcornLeft + " left";
                    }
                    return "Deal over! All popcorns claimed.";
                } finally {
                    lock.unlock();
                }
            } else {
                return "Too many people! Please try again in a moment.";
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return "Request cancelled.";
        }
    }
}

ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
    // critical section — do the important stuff
} finally {
    lock.unlock();  // if you forget this, the lock is held FOREVER
}

public class BookingService {
    private final ReentrantLock lock = new ReentrantLock();

    public void bookSeat(String userId) {
        lock.lock();  // lock count = 1
        try {
            validateAndReserve(userId);
        } finally {
            lock.unlock();  // count = 0, lock released
        }
    }

    private void validateAndReserve(String userId) {
        lock.lock();  // SAME thread — count goes to 2, NO deadlock
        try {
            // validate user, reserve seat
        } finally {
            lock.unlock();  // count back to 1
        }
    }
}

// UNFAIR (default) — faster, but some threads may starve
ReentrantLock unfairLock = new ReentrantLock();

// FAIR — strictly FIFO, longest-waiting thread goes first
ReentrantLock fairLock = new ReentrantLock(true);

public class CloudKitchenQueue {
    private final Queue<FoodOrder> orders = new LinkedList<>();
    private final int maxOrders = 50;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition chefsWaiting = lock.newCondition();     // chefs wait here
    private final Condition customersWaiting = lock.newCondition(); // customers wait here

    // Customer places an order
    public void placeOrder(FoodOrder order) throws InterruptedException {
        lock.lock();
        try {
            while (orders.size() == maxOrders) {
                customersWaiting.await();  // kitchen full — customer waits
            }
            orders.add(order);
            chefsWaiting.signal();         // "Hey chef, new order!"
        } finally {
            lock.unlock();
        }
    }

    // Chef picks up next order
    public FoodOrder pickNextOrder() throws InterruptedException {
        lock.lock();
        try {
            while (orders.isEmpty()) {
                chefsWaiting.await();      // no orders — chef waits
            }
            FoodOrder order = orders.poll();
            customersWaiting.signal();     // "Hey customer, space freed up!"
            return order;
        } finally {
            lock.unlock();
        }
    }
}

public class FeatureFlagService {
    private final Map<String, Boolean> flags = new HashMap<>();
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

    // Called 500,000 times/sec — all readers run SIMULTANEOUSLY
    public boolean isEnabled(String flagName) {
        rwLock.readLock().lock();
        try {
            return flags.getOrDefault(flagName, false);
        } finally {
            rwLock.readLock().unlock();
        }
    }

    // Called 5 times/day by product manager — gets exclusive access
    public void updateFlag(String flagName, boolean enabled) {
        rwLock.writeLock().lock();
        try {
            flags.put(flagName, enabled);
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    // Also a read — runs concurrently with other reads
    public Map<String, Boolean> getAllFlags() {
        rwLock.readLock().lock();
        try {
            return new HashMap<>(flags);
        } finally {
            rwLock.readLock().unlock();
        }
    }
}

public class LiveScoreBoard {
    private int runs, wickets, overs;
    private String lastEvent;
    private final StampedLock lock = new StampedLock();

    // Called when a ball is bowled (~40 times in 20 min)
    public void updateScore(int newRuns, int newWickets, int newOvers, String event) {
        long stamp = lock.writeLock();
        try {
            this.runs = newRuns;
            this.wickets = newWickets;
            this.overs = newOvers;
            this.lastEvent = event;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    // Called 2 MILLION times/sec — almost zero overhead
    public String getScore() {
        long stamp = lock.tryOptimisticRead();  // NO lock acquired! Just a stamp number.
        int r = runs;
        int w = wickets;
        int o = overs;
        String e = lastEvent;

        if (!lock.validate(stamp)) {
            // A ball was bowled while we were reading — extremely rare
            stamp = lock.readLock();
            try {
                r = runs;
                w = wickets;
                o = overs;
                e = lastEvent;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return r + "/" + w + " (" + o + " ov) — " + e;
    }
}

// Thread-1: Priya transfers ₹5000 from Account-A → Account-B
// Thread-2: Karan transfers ₹3000 from Account-B → Account-A
// (both happen at the exact same millisecond)

public void transfer(Account from, Account to, double amount) {
    synchronized (from) {
        Thread.sleep(1);  // simulate some processing
        synchronized (to) {
            from.debit(amount);
            to.credit(amount);
        }
    }
}

public void transfer(Account from, Account to, double amount) {
    // Always lock lower-ID first, regardless of transfer direction
    Account first  = from.getId() < to.getId() ? from : to;
    Account second = from.getId() < to.getId() ? to : from;

    synchronized (first) {
        synchronized (second) {
            from.debit(amount);
            to.credit(amount);
        }
    }
}

// BUG — each call creates a NEW lock object!
public void processPayment(Payment p) {
    Object lock = new Object();       // local variable — each thread gets its own
    synchronized (lock) {
        deductBalance(p.getAmount()); // NOT actually protected
    }
}
// It's like each person bringing their own bathroom door. Everyone walks in simultaneously.

// FIX — lock must be SHARED across threads
private final Object lock = new Object();  // instance field — all threads share this

public void processPayment(Payment p) {
    synchronized (lock) {
        deductBalance(p.getAmount()); // NOW protected
    }
}

// BUG — lock reference changes!
private String currentPromo = "DIWALI50";

public void updatePromo(String newPromo) {
    synchronized (currentPromo) {         // Thread-1 locks the String "DIWALI50"
        currentPromo = newPromo;          // now currentPromo points to "NEWYEAR25"
    }                                     // Thread-2 locks "NEWYEAR25" — DIFFERENT object!
}
// Two threads locking on different objects = no protection at all

// FIX — lock on a dedicated final object that never changes
private final Object promoLock = new Object();
private String currentPromo = "DIWALI50";

public void updatePromo(String newPromo) {
    synchronized (promoLock) {            // always the same object
        currentPromo = newPromo;
    }
}

// BUG — if processOrder() throws an exception, lock is held FOREVER
lock.lock();
Order order = processOrder();  // throws NullPointerException!
lock.unlock();                 // NEVER REACHED
// Every other thread: blocked. Forever. Entire service is dead.

// FIX — always use try-finally
lock.lock();
try {
    Order order = processOrder();  // even if this throws...
} finally {
    lock.unlock();                 // ...this ALWAYS runs
}

// BROKEN — without volatile, Thread-2 may see partially constructed object
public class ConfigManager {
    private static ConfigManager instance;

    public static ConfigManager getInstance() {
        if (instance == null) {                    // Check 1 (no lock)
            synchronized (ConfigManager.class) {
                if (instance == null) {             // Check 2 (with lock)
                    instance = new ConfigManager(); // NOT atomic! Can be reordered.
                }
            }
        }
        return instance;  // Thread-2 may get a half-initialized object
    }
}

// FIX — add volatile
private static volatile ConfigManager instance;
// volatile prevents instruction reordering, ensuring the object is fully
// constructed before the reference is published to other threads