public class Counter {
    private int value = 0;
    public void increment() {
        value++;
    }
}

javac Counter.java
javap -c Counter

public void increment();
  Code:
     0: aload_0            // push the 'this' reference
     1: dup                // duplicate it (needed twice)
     2: getfield #7        // READ  the 'value' field   <-- operation 1
     5: iconst_1           // push the constant 1
     6: iadd               // ADD                       <-- operation 2
     7: putfield #7        // WRITE the 'value' field   <-- operation 3
    10: return

value++;                     // read, add, write
value--;                     // same
value += 5;                  // same
balance = balance - amount;  // same
if (!map.containsKey(k)) {   // CHECK...
    map.put(k, v);           // ...THEN ACT: another thread can slip in between
}
if (instance == null) {      // the classic lazy singleton
    instance = new Service();
}
list.add(list.size(), x);    // read the size, then use it

public class TornLong {
    // Without volatile, on a 32-bit JVM, a reader could see
    // 0x00000000FFFFFFFF: half of one value and half of another.
    private long loanCounter = 0;

    // With volatile, the 64-bit write is atomic by specification.
    private volatile long safeCounter = 0;
}

// What you write:
data = loadCatalogue();       // (1)
ready = true;                 // (2)

// What the compiler may generate, because for THIS thread
// the result is indistinguishable:
ready = true;                 // (2)
data = loadCatalogue();       // (1)

public class FlagWithoutVolatile {

    // NO volatile. There is the problem.
    private static boolean stop = false;

    public static void main(String[] args) throws InterruptedException {

        Thread worker = new Thread(() -> {
            long rounds = 0;
            // The JIT can turn this into 'while (true)' because
            // inside THIS thread 'stop' never changes: it is a
            // legal optimisation called hoisting.
            while (!stop) {
                rounds++;
            }
            System.out.println("[worker] stopped after " + rounds + " rounds");
        }, "bibliotech-worker");

        worker.start();

        Thread.sleep(1000);
        System.out.println("[main] writing stop = true");
        stop = true;

        worker.join(3000);
        if (worker.isAlive()) {
            System.out.println("[main] THE WORKER HAS NOT NOTICED. Still alive.");
            System.exit(1);
        }
    }
}

[main] writing stop = true
[main] THE WORKER HAS NOT NOTICED. Still alive.

boolean copy = stop;         // read ONCE
while (!copy) { rounds++; }  // infinite loop

[main] writing stop = true
[worker] stopped after 1847239104 rounds

// start() RULE: main writes, the new thread is guaranteed to see it.
catalog.load();                     // A
Thread t = new Thread(task);
t.start();                          // A happens-before everything in the new thread
// inside 'task': it sees the loaded catalogue, guaranteed.

// join() RULE: the thread writes, main is guaranteed to see it.
t.start();
t.join();                           // everything in the thread hb join returning
System.out.println(task.result());       // correct value guaranteed

// MONITOR RULE: visibility transfer between critical sections.
synchronized (lock) { x = 42; }          // releasing hb...
// ... another thread:
synchronized (lock) { read(x); }         // ...acquiring: sees x == 42

// volatile RULE + transitivity: the "safe publication" idiom.
data = loadCatalogue();            // (1) ordinary write
ready = true;                      // (2) VOLATILE write
// ... another thread:
if (ready) {                       // (3) VOLATILE read
    use(data);                     // (4) sees data correctly. Why?
}
// (1) hb (2) by program order;
// (2) hb (3) by the volatile rule;
// (3) hb (4) by program order;
// by transitivity: (1) hb (4). Accessing 'data' is safe
// EVEN THOUGH 'data' is not volatile.

package com.nexussoftware.bibliotech.persistence;

/**
 * Import service with a clean stop through a volatile flag.
 * It complements the interruption of 08-02: an own flag allows
 * an orderly stop without depending on the interrupt status.
 */
public class ImportService implements Runnable {

    // volatile: written by the menu thread, read by the worker thread.
    // WITHOUT volatile, the worker might NEVER notice (section 3.2).
    private volatile boolean stop = false;

    // Progress published towards the menu thread. Only THIS thread writes it,
    // so there is no concurrent read-modify-write: volatile is enough.
    private volatile int linesProcessed = 0;

    public void stop() {
        stop = true;
    }

    @Override
    public void run() {
        while (!stop && !Thread.currentThread().isInterrupted()) {
            processBatch();
            linesProcessed += 1000;       // safe: a SINGLE writer
        }
    }

    public int linesProcessed() { return linesProcessed; }

    private void processBatch() { /* ... */ }
}

public class VolatileCounterStillBroken {

    // volatile DOES guarantee both threads see the most recent value.
    // volatile does NOT guarantee that 'value++' is indivisible.
    private volatile int value = 0;

    public void increment() {
        value++;      // it is still READ, ADD, WRITE
    }

    public int value() { return value; }

    public static void main(String[] args) throws InterruptedException {
        final int ROUNDS = 1_000_000;

        for (int attempt = 1; attempt <= 3; attempt++) {
            VolatileCounterStillBroken c = new VolatileCounterStillBroken();

            Thread t1 = new Thread(() -> { for (int i = 0; i < ROUNDS; i++) c.increment(); });
            Thread t2 = new Thread(() -> { for (int i = 0; i < ROUNDS; i++) c.increment(); });

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

            System.out.printf("Attempt %d: expected %d, actual %d, lost %d%n",
                    attempt, ROUNDS * 2, c.value(), ROUNDS * 2 - c.value());
        }
    }
}

Attempt 1: expected 2000000, actual 1223981, lost 776019
Attempt 2: expected 2000000, actual 1341102, lost 658898
Attempt 3: expected 2000000, actual 1189447, lost 810553

// A volatile 'catalog' guarantees you see the most recent reference...
private volatile List<Material> catalog = new ArrayList<>();

// ...but it does NOT protect the CONTENTS of the list.
catalog.add(newBook);       // still a data race

synchronized (object) {
    // only one thread at a time can be here
}

public class SynchronizedCounter {

    private int value = 0;

    // Synchronized instance method: it acquires 'this's monitor.
    public synchronized void increment() {
        value++;      // now the three operations are indivisible
                      // with respect to other threads using THIS monitor
    }

    // ALSO synchronized. If it were not, a reader could see
    // a stale value: mutual exclusion without visibility is not enough.
    public synchronized int value() {
        return value;
    }

    public static void main(String[] args) throws InterruptedException {
        final int ROUNDS = 1_000_000;

        for (int attempt = 1; attempt <= 3; attempt++) {
            SynchronizedCounter c = new SynchronizedCounter();
            Thread t1 = new Thread(() -> { for (int i = 0; i < ROUNDS; i++) c.increment(); });
            Thread t2 = new Thread(() -> { for (int i = 0; i < ROUNDS; i++) c.increment(); });
            t1.start(); t2.start();
            t1.join();  t2.join();
            System.out.printf("Attempt %d: expected %d, actual %d%n",
                    attempt, ROUNDS * 2, c.value());
        }
    }
}

Attempt 1: expected 2000000, actual 2000000
Attempt 2: expected 2000000, actual 2000000
Attempt 3: expected 2000000, actual 2000000

public class Reentrancy {

    public synchronized void registerLoan(String isbn) {
        validate(isbn);
        // Call to ANOTHER synchronized method on the SAME object.
        // Without reentrancy, the thread would block itself: an instant
        // deadlock with itself.
        updateIndex(isbn);
    }

    public synchronized void updateIndex(String isbn) { /* ... */ }

    private void validate(String isbn) { /* ... */ }
}

public synchronized void add(Material m) { /* ... */ }

// It is EXACTLY equivalent to:
public void add(Material m) {
    synchronized (this) { /* ... */ }
}

public static synchronized void logGlobally(String event) { /* ... */ }

// Equivalent to:
public static void logGlobally(String event) {
    synchronized (Catalog.class) { /* ... */ }
}

public class TwoDifferentMonitors {
    private static int globalCounter = 0;

    // Locks 'this'
    public synchronized void incrementWrong() { globalCounter++; }

    // Locks 'TwoDifferentMonitors.class'
    public static synchronized void incrementStatic() { globalCounter++; }

    // These two methods do NOT exclude each other: they use different locks.
    // The static state they share is NOT protected. BUG.
}

private final Object lock = new Object();

public void add(Material m) {
    // Work that does NOT need protection, outside the lock:
    validate(m);
    String key = normalise(m.isbn());

    synchronized (lock) {
        // Critical section: the bare minimum
        materials.add(m);
        index.put(key, m);
    }

    // More non-critical work
    recordInAudit(m);
}

public class Catalog {
    // PRIVATE and FINAL lock: nobody outside can acquire it,
    // and nobody can reassign it (a reassigned lock stops
    // protecting: two threads could lock different objects).
    private final Object lock = new Object();

    // And NEVER use something like this as a lock:
    //   private final Integer lock = 42;         // <- may be interned
    //   private final String lock = "cat";       // <- interned literal: SHARED
    //   private final Boolean lock = false;      // <- Boolean.FALSE, shared
    // A String literal or a small Integer is a UNIQUE object across the JVM:
    // another class using the same literal shares your lock without knowing.
}

// WRONG: 300 ms of I/O inside the lock. Every other thread waits.
public void registerLoan(Loan l) {
    synchronized (lock) {
        loans.put(l.id(), l);
        writeToDisk(l);                  // 300 ms of I/O
        sendNotification(l.employee());  // another 200 ms
    }
}

// RIGHT: only the in-memory state change is protected.
public void registerLoan(Loan l) {
    synchronized (lock) {
        loans.put(l.id(), l);            // microseconds
    }
    writeToDisk(l);                      // outside the lock
    sendNotification(l.employee());      // outside the lock
}

// DANGEROUS: 'listeners' contains code you do not control.
synchronized (lock) {
    for (CatalogListener l : listeners) {
        l.materialAdded(m);      // what does it do? does it block? call back?
    }
}

// SAFE: copy under the lock, notify outside.
List<CatalogListener> copy;
synchronized (lock) {
    copy = new ArrayList<>(listeners);
}
for (CatalogListener l : copy) {
    l.materialAdded(m);          // no lock: it cannot block us
}

public class LoanRegistry {
    private final Object lock = new Object();

    /** Guarded by 'lock'. */
    private final Map<String, Loan> byId = new HashMap<>();

    /** Guarded by 'lock'. Invariant: contains the same loans as 'byId'. */
    private final Map<Employee, List<Loan>> byEmployee = new HashMap<>();
}

package com.nexussoftware.bibliotech.service;

import java.util.concurrent.TimeUnit;

public class LoanTransfer {

    /** Each employee has their own lock and their loan count. */
    static class EmployeeAccount {
        final String name;
        final Object lock = new Object();
        int loans;

        EmployeeAccount(String name, int loans) {
            this.name = name;
            this.loans = loans;
        }
    }

    /**
     * DEADLOCKING VERSION.
     * Locks 'source' and then 'target'. If two threads transfer
     * in opposite directions, the cycle forms.
     */
    static void transferWrong(EmployeeAccount source, EmployeeAccount target, int n) {
        synchronized (source.lock) {
            pause(100);                        // widens the failure window
            synchronized (target.lock) {
                source.loans -= n;
                target.loans += n;
                System.out.printf("  %s -> %s : %d loans%n",
                        source.name, target.name, n);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        EmployeeAccount marta = new EmployeeAccount("Marta Ruiz", 5);
        EmployeeAccount diego = new EmployeeAccount("Diego Alonso", 5);

        // Thread 1: marta -> diego  (locks marta, then diego)
        Thread t1 = new Thread(() -> transferWrong(marta, diego, 1), "thread-marta-diego");
        // Thread 2: diego -> marta  (locks diego, then marta)  <-- REVERSE ORDER
        Thread t2 = new Thread(() -> transferWrong(diego, marta, 1), "thread-diego-marta");

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

        t1.join(3000);
        t2.join(3000);

        if (t1.isAlive() || t2.isAlive()) {
            System.out.println("DEADLOCK: both threads are still alive and blocked.");
            System.out.println("State t1: " + t1.getState());
            System.out.println("State t2: " + t2.getState());
            System.exit(1);
        }
    }
}

DEADLOCK: both threads are still alive and blocked.
State t1: BLOCKED
State t2: BLOCKED

/**
 * CORRECT VERSION: global acquisition order.
 * The locks are ALWAYS taken in increasing identityHashCode order,
 * regardless of the direction of the transfer.
 */
static void transferRight(EmployeeAccount source, EmployeeAccount target, int n) {

    int hs = System.identityHashCode(source);
    int ht = System.identityHashCode(target);

    if (hs < ht) {
        synchronized (source.lock) {
            synchronized (target.lock) {
                move(source, target, n);
            }
        }
    } else if (hs > ht) {
        synchronized (target.lock) {          // order REVERSED with respect to the
            synchronized (source.lock) {      // business, but CONSISTENT across threads
                move(source, target, n);
            }
        }
    } else {
        // Extremely rare case: identityHashCode collision between two
        // different objects. A third global lock breaks the tie and
        // guarantees only one thread takes this path at a time.
        synchronized (TIE_BREAK_LOCK) {
            synchronized (source.lock) {
                synchronized (target.lock) {
                    move(source, target, n);
                }
            }
        }
    }
}

private static final Object TIE_BREAK_LOCK = new Object();

private static void move(EmployeeAccount source, EmployeeAccount target, int n) {
    source.loans -= n;
    target.loans += n;
}

// With a natural identifier, far clearer:
EmployeeAccount first = source.id().compareTo(target.id()) < 0 ? source : target;
EmployeeAccount second = (first == source) ? target : source;

synchronized (first.lock) {
    synchronized (second.lock) {
        move(source, target, n);
    }
}

import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TransferWithTryLock {

    static class EmployeeAccount {
        final String name;
        final ReentrantLock lock = new ReentrantLock();
        int loans;
        EmployeeAccount(String name, int loans) {
            this.name = name; this.loans = loans;
        }
    }

    /**
     * Acquires both locks with a deadline. If it fails to get both,
     * it releases whatever it holds, waits a RANDOM time and retries.
     * The randomness is essential: without it, two threads could retry
     * in lockstep forever (livelock, section 12).
     */
    static boolean transfer(EmployeeAccount source, EmployeeAccount target,
                            int n, int maxAttempts) throws InterruptedException {

        for (int attempt = 0; attempt < maxAttempts; attempt++) {
            boolean haveSource = false;
            boolean haveTarget = false;
            try {
                haveSource = source.lock.tryLock(50, TimeUnit.MILLISECONDS);
                if (haveSource) {
                    haveTarget = target.lock.tryLock(50, TimeUnit.MILLISECONDS);
                }
                if (haveSource && haveTarget) {
                    source.loans -= n;
                    target.loans += n;
                    return true;                     // success
                }
            } finally {
                // ALWAYS release what was acquired, in reverse order.
                if (haveTarget) target.lock.unlock();
                if (haveSource) source.lock.unlock();
            }
            // Random backoff before retrying.
            TimeUnit.MILLISECONDS.sleep(
                    ThreadLocalRandom.current().nextInt(10, 60));
        }
        return false;                                // attempts exhausted
    }
}

// If transfers are not 90% of the load, this is
// simpler, safer and probably just as fast.
private static final Object TRANSFER_LOCK = new Object();

static void transfer(EmployeeAccount source, EmployeeAccount target, int n) {
    synchronized (TRANSFER_LOCK) {
        source.loans -= n;
        target.loans += n;
    }
}

// The true parameter enables the FIFO policy: the lock is granted
// to the thread that has been waiting longest.
// COST: much lower performance (often 10x or more), because it prevents
// opportunistic barging and forces context switches.
// Use it only if you have measured real starvation.
ReentrantLock fair = new ReentrantLock(true);

// LIVELOCK: if the two threads get in phase, they can retry
// forever, always yielding at the same time.
while (true) {
    if (a.tryLock()) {
        if (b.tryLock()) { doWork(); return; }
        a.unlock();          // yields
    }
    // with no random wait: both threads try again
    // at exactly the same moment, again, and again
}

import java.util.concurrent.locks.ReentrantLock;

public class LockCounter {

    private final ReentrantLock lock = new ReentrantLock();
    private int value = 0;

    public void increment() {
        lock.lock();
        try {
            value++;
        } finally {
            // MANDATORY in finally: if the body throws an exception
            // and the unlock is outside, the lock is NEVER released
            // and the whole application blocks. It is the number-one
            // ReentrantLock mistake, and the reason synchronized is
            // still preferable when you need nothing more.
            lock.unlock();
        }
    }
}

if (lock.tryLock()) {              // never blocks
    try { operation(); } finally { lock.unlock(); }
} else {
    // plan B: queue it, tell the user, retry later
}

try {
    lock.lockInterruptibly();      // responds to interrupt() while waiting
    try { operation(); } finally { lock.unlock(); }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

package com.nexussoftware.bibliotech.service;

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

/**
 * Bounded reservation queue with two separate conditions.
 *
 * Advantage over wait/notifyAll (08-03): freeing a slot wakes only
 * a PRODUCER, and adding an element only a CONSUMER.
 * With notifyAll everybody woke up and most went straight back to sleep.
 *
 * NOTE: in production you would use ArrayBlockingQueue (08-06), which is
 * exactly this, already implemented and tested.
 */
public class ReservationQueueWithCondition {

    private final ReentrantLock lock = new ReentrantLock();

    // TWO conditions over the SAME lock.
    private final Condition spaceAvailable = lock.newCondition();
    private final Condition itemAvailable  = lock.newCondition();

    private final Deque<String> queue = new ArrayDeque<>();
    private final int capacity;

    public ReservationQueueWithCondition(int capacity) {
        this.capacity = capacity;
    }

    public void put(String reservation) throws InterruptedException {
        lock.lock();
        try {
            // WHILE, just as with wait(): the same three reasons from 08-03.
            while (queue.size() == capacity) {
                spaceAvailable.await();    // releases the lock and waits
            }
            queue.addLast(reservation);
            itemAvailable.signal();        // wakes ONE consumer.
                                           // Safe: only consumers wait on
                                           // this queue, and they are all
                                           // interchangeable.
        } finally {
            lock.unlock();
        }
    }

    public String take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                itemAvailable.await();
            }
            String r = queue.pollFirst();
            spaceAvailable.signal();       // wakes ONE producer
            return r;
        } finally {
            lock.unlock();
        }
    }

    public int size() {
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }
}

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.Material;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Thread-safe catalogue, optimised for reading.
 *
 * Rationale for the ReadWriteLock: in BiblioTech the catalogue is queried
 * dozens of times for every insertion (find by ISBN, list, filter by type),
 * and insertions arrive in batches during the import.
 */
public class SafeCatalog {

    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock  read  = lock.readLock();
    private final ReentrantReadWriteLock.WriteLock write = lock.writeLock();

    /** Guarded by 'lock'. */
    private final List<Material> materials = new ArrayList<>();
    /** Guarded by 'lock'. Invariant: one entry per material. */
    private final Map<String, Material> index = new HashMap<>();
    /** Guarded by 'lock'. Invariant: same ISBNs as 'index'. */
    private final Set<String> registeredIsbns = new HashSet<>();

    // ---------- WRITES: exclusive lock ----------

    public boolean add(Material m) {
        write.lock();
        try {
            if (!registeredIsbns.add(m.isbn())) {
                return false;                // it already existed
            }
            materials.add(m);
            index.put(m.isbn(), m);
            return true;
        } finally {
            write.unlock();
        }
    }

    public boolean remove(String isbn) {
        write.lock();
        try {
            Material m = index.remove(isbn);
            if (m == null) return false;
            materials.remove(m);
            registeredIsbns.remove(isbn);
            return true;
        } finally {
            write.unlock();
        }
    }

    /** Complete atomic replacement: what the 08-02 import uses. */
    public void replaceAll(List<Material> fresh) {
        write.lock();
        try {
            materials.clear();
            index.clear();
            registeredIsbns.clear();
            for (Material m : fresh) {
                if (registeredIsbns.add(m.isbn())) {
                    materials.add(m);
                    index.put(m.isbn(), m);
                }
            }
        } finally {
            write.unlock();
        }
    }

    // ---------- READS: shared lock ----------

    public Material findByIsbn(String isbn) {
        read.lock();
        try {
            return index.get(isbn);
        } finally {
            read.unlock();
        }
    }

    public int size() {
        read.lock();
        try {
            return materials.size();
        } finally {
            read.unlock();
        }
    }

    /**
     * Returns a COPY. Returning the internal list would be a thread-safety
     * failure: whoever received it could iterate it without the lock
     * while another thread modifies it -> ConcurrentModificationException
     * (05-02) or something worse.
     */
    public List<Material> list() {
        read.lock();
        try {
            return new ArrayList<>(materials);    // copy under the lock
        } finally {
            read.unlock();
        }
    }
}

// FORBIDDEN: upgrading. It hangs forever.
read.lock();
write.lock();         // waits for ALL the read locks to be released,
                      // including OURS. Deadlock.

// ALLOWED: downgrading (write -> read).
write.lock();
try {
    modify();
    read.lock();          // acquire read BEFORE releasing write
} finally {
    write.unlock();       // now we only hold read
}
try {
    readWhatWeJustWrote();
} finally {
    read.unlock();
}

// UNSAFE PUBLICATION
public class Registry {
    public static Catalog instance;      // no volatile, no final

    public static void initialise() {
        instance = new Catalog();        // (1) allocate (2) construct (3) assign
        // Phases (2) and (3) can be REORDERED: another thread can see
        // 'instance' non-null pointing at an unconstructed object.
    }
}

package com.nexussoftware.bibliotech.domain;

/**
 * Immutable card: all its fields are final because it is a record.
 * Shareable between any number of threads with no synchronisation.
 */
public record Card(String isbn, String title, String author, int copies) { }

/**
 * Immutable SessionSummary. Careful: if a record contains a collection,
 * the collection must be immutable too, or the record is only
 * "shallowly" immutable.
 */
public record SessionSummary(long startMs, long endMs,
                             int loans, int returns,
                             List<String> incidents) {

    /** Compact constructor with a defensive copy: it makes the list immutable. */
    public SessionSummary {
        incidents = List.copyOf(incidents);       // IMMUTABLE copy
    }
}

public class BiblioTechStatistics {

    /** Immutable snapshot of the statistics. */
    public record Snapshot(long loans, long returns, long fines) {
        Snapshot withLoan()   { return new Snapshot(loans + 1, returns, fines); }
        Snapshot withReturn() { return new Snapshot(loans, returns + 1, fines); }
    }

    // The REFERENCE is volatile: readers always see a complete
    // and consistent snapshot, never a half-finished one.
    private volatile Snapshot current = new Snapshot(0, 0, 0);

    /** A lock-free read: consistent through immutability. */
    public Snapshot snapshot() {
        return current;
    }

    /**
     * The write DOES need synchronisation: 'current = current.withLoan()'
     * is read-modify-write, and volatile does not make it atomic (section 6).
     * In 08-06 this will be solved with AtomicReference.updateAndGet, lock-free.
     */
    public synchronized void registerLoan() {
        current = current.withLoan();
    }
}

public Report processBatch(List<String> lines) {
    // ALL local: each thread has its own list and its own counter.
    // No locks, no possible race.
    List<Material> accepted = new ArrayList<>();
    int discarded = 0;

    for (String l : lines) {
        try {
            accepted.add(reader.toMaterial(l));
        } catch (InvalidFormatException e) {
            discarded++;
        }
    }
    // The only point of contact with shared state, and it is protected:
    catalog.addAll(accepted);
    return new Report(accepted.size(), discarded);
}

import java.text.NumberFormat;
import java.util.Locale;

public class FineFormat {

    // NumberFormat is NOT thread-safe: sharing one instance
    // produces corrupt results under load (a classic that is very hard to
    // diagnose because it fails rarely and silently).
    // ThreadLocal gives one instance per thread: safe and lock-free.
    private static final ThreadLocal<NumberFormat> FORMAT =
            ThreadLocal.withInitial(() -> NumberFormat.getCurrencyInstance(
                    Locale.forLanguageTag("en-GB")));

    public static String format(double amount) {
        return FORMAT.get().format(amount);
    }

    /**
     * IMPORTANT: in a thread pool (08-05) the threads are reused
     * indefinitely, so a ThreadLocal is never released on its own.
     * If it holds anything large or sensitive, it must be cleared:
     */
    public static void clear() {
        FORMAT.remove();
    }
}

// Each thread processes ITS chunk and produces ITS partial result.
// There is no shared state during the computation, only when combining.
// It is the model of ForkJoinPool (08-05) and of parallel streams (10-04).
List<Report> partials = new ArrayList<>();
// ... each thread returns its Report, and at the end:
Report total = combine(partials);      // a single thread, no locks

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.Employee;
import com.nexussoftware.bibliotech.domain.Loan;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Thread-safe loan registry.
 *
 * SYNCHRONISATION POLICY
 * ----------------------
 * All the mutable state is guarded by 'lock'.
 * Queries use the read lock (shared);
 * modifications, the write lock (exclusive).
 *
 * INVARIANT: 'byId' and 'byEmployee' contain exactly the same
 * set of loans. This invariant spans TWO structures, and that
 * is why two ConcurrentHashMaps (08-06) are not enough: the two
 * updates would have to be a single atomic operation, and only
 * a lock gives that.
 */
public class SafeLoanRegistry {

    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock  read  = lock.readLock();
    private final ReentrantReadWriteLock.WriteLock write = lock.writeLock();

    /** Guarded by 'lock'. */
    private final Map<String, Loan> byId = new HashMap<>();
    /** Guarded by 'lock'. Invariant: consistent with 'byId'. */
    private final Map<Employee, List<Loan>> byEmployee = new HashMap<>();

    // ---------- WRITING ----------

    /**
     * Registers a loan. Both updates happen under the same lock,
     * so no reader can see the intermediate state in which the
     * loan is in 'byId' but not yet in 'byEmployee'.
     */
    public void register(Loan l) {
        write.lock();
        try {
            if (byId.putIfAbsent(l.id(), l) != null) {
                throw new IllegalStateException("Duplicate loan: " + l.id());
            }
            byEmployee.computeIfAbsent(l.employee(), e -> new ArrayList<>()).add(l);
        } finally {
            write.unlock();
        }
    }

    public Loan returnItem(String loanId) {
        write.lock();
        try {
            Loan l = byId.remove(loanId);
            if (l == null) {
                throw new LoanNotFoundException(loanId);
            }
            List<Loan> ofEmployee = byEmployee.get(l.employee());
            if (ofEmployee != null) {
                ofEmployee.remove(l);
                if (ofEmployee.isEmpty()) {
                    byEmployee.remove(l.employee());    // do not leave empty lists
                }
            }
            return l;
        } finally {
            write.unlock();
        }
    }

    // ---------- READING ----------

    public Loan find(String loanId) {
        read.lock();
        try {
            return byId.get(loanId);
        } finally {
            read.unlock();
        }
    }

    /** Returns a COPY: the internal list never leaves the lock. */
    public List<Loan> loansOf(Employee e) {
        read.lock();
        try {
            List<Loan> l = byEmployee.get(e);
            return l == null ? List.of() : new ArrayList<>(l);
        } finally {
            read.unlock();
        }
    }

    public int active() {
        read.lock();
        try {
            return byId.size();
        } finally {
            read.unlock();
        }
    }

    /**
     * ATOMIC COMPOUND OPERATION.
     *
     * This method exists precisely because doing it from outside would be
     * an unsafe check-then-act:
     *
     *     if (registry.active() < MAX) registry.register(l);   // BUG
     *
     * Between the check and the action, another thread can register and
     * exceed the limit. Encapsulating the complete operation inside the
     * lock is the only correct way.
     */
    public boolean registerIfWithinAllowance(Loan l, int maxPerEmployee) {
        write.lock();
        try {
            List<Loan> currentOnes = byEmployee.get(l.employee());
            if (currentOnes != null && currentOnes.size() >= maxPerEmployee) {
                return false;
            }
            byId.put(l.id(), l);
            byEmployee.computeIfAbsent(l.employee(), e -> new ArrayList<>()).add(l);
            return true;
        } finally {
            write.unlock();
        }
    }
}

package com.nexussoftware.bibliotech.service;

import java.util.concurrent.TimeUnit;

public class RegistryConcurrencyTest {

    public static void main(String[] args) throws InterruptedException {

        final int THREADS = 8;
        final int PER_THREAD = 5_000;

        SafeLoanRegistry registry = new SafeLoanRegistry();
        Employee marta = new Employee("EMP-001", "Marta Ruiz");

        Thread[] threads = new Thread[THREADS];
        long start = System.nanoTime();

        for (int h = 0; h < THREADS; h++) {
            final int threadId = h;
            threads[h] = new Thread(() -> {
                for (int i = 0; i < PER_THREAD; i++) {
                    registry.register(new Loan(
                            "LN-" + threadId + "-" + i, marta, "978-0000000001"));
                }
            }, "bibliotech-registrar-" + h);
            threads[h].start();
        }

        for (Thread t : threads) t.join();

        long ms = (System.nanoTime() - start) / 1_000_000;
        int expected = THREADS * PER_THREAD;
        int actual = registry.active();
        int inList = registry.loansOf(marta).size();

        System.out.println("Expected            : " + expected);
        System.out.println("In byId             : " + actual);
        System.out.println("In byEmployee       : " + inList);
        System.out.println("Invariant consistent: " + (actual == inList));
        System.out.println("Time                : " + ms + " ms");
        System.out.println(actual == expected && actual == inList
                ? "CORRECT"
                : "FAILURE: there is a data race");
    }
}

Expected            : 40000
In byId             : 40000
In byEmployee       : 40000
Invariant consistent: true
Time                : 187 ms
CORRECT

import java.util.concurrent.locks.ReentrantLock;

public class CounterComparison {

    interface Counter {
        void increment();
        long value();
        String name();
    }

    /** 1. UNSAFE: value++ is read-modify-write with no protection. */
    static class UnsafeCounter implements Counter {
        private long value = 0;
        public void increment() { value++; }
        public long value() { return value; }
        public String name() { return "plain int"; }
    }

    /** 2. VOLATILE: solves visibility, NOT atomicity. */
    static class VolatileCounter implements Counter {
        private volatile long value = 0;
        public void increment() { value++; }
        public long value() { return value; }
        public String name() { return "volatile"; }
    }

    /** 3. SYNCHRONIZED: mutual exclusion + visibility. Correct. */
    static class SynchronizedCounter implements Counter {
        private long value = 0;
        public synchronized void increment() { value++; }
        // The getter is ALSO synchronized: without it, a reader could
        // see a stale value from its cache.
        public synchronized long value() { return value; }
        public String name() { return "synchronized"; }
    }

    /** 4. REENTRANTLOCK: equivalent, with unlock in finally. */
    static class LockCounter implements Counter {
        private final ReentrantLock lock = new ReentrantLock();
        private long value = 0;

        public void increment() {
            lock.lock();                    // OUTSIDE the try
            try { value++; }
            finally { lock.unlock(); }      // ALWAYS in finally
        }

        public long value() {
            lock.lock();
            try { return value; }
            finally { lock.unlock(); }
        }
        public String name() { return "ReentrantLock"; }
    }

    static long measure(Counter c, int threads, int perThread) throws InterruptedException {
        Thread[] ts = new Thread[threads];
        long start = System.nanoTime();
        for (int i = 0; i < threads; i++) {
            ts[i] = new Thread(() -> {
                for (int j = 0; j < perThread; j++) c.increment();
            }, "adder-" + i);
            ts[i].start();
        }
        for (Thread t : ts) t.join();
        return System.nanoTime() - start;
    }

    public static void main(String[] args) throws InterruptedException {

        final int THREADS = 8;
        final int PER_THREAD = 500_000;
        final long EXPECTED = (long) THREADS * PER_THREAD;

        Counter[] counters = {
                new UnsafeCounter(), new VolatileCounter(),
                new SynchronizedCounter(), new LockCounter()
        };

        // Warm-up: without it, the first implementations pay for
        // the JIT compilation and the comparison is not fair.
        for (Counter c : counters) measure(c, 2, 10_000);

        System.out.printf("%-16s | %12s | %10s | %8s | %12s%n",
                "Implementation", "Result", "Lost", "ms", "inc/ms");
        System.out.println("-----------------|--------------|------------|----------|-------------");

        for (Counter template : counters) {
            // A fresh instance so as not to carry the warm-up over.
            Counter c = switch (template.name()) {
                case "plain int"     -> new UnsafeCounter();
                case "volatile"      -> new VolatileCounter();
                case "synchronized"  -> new SynchronizedCounter();
                default              -> new LockCounter();
            };

            long ns = measure(c, THREADS, PER_THREAD);
            long ms = ns / 1_000_000;
            long lost = EXPECTED - c.value();

            System.out.printf("%-16s | %12d | %10d | %8d | %12d%s%n",
                    c.name(), c.value(), lost, ms,
                    ms == 0 ? 0 : c.value() / ms,
                    lost == 0 ? "" : "   <-- INCORRECT");
        }
    }
}

Implementation   |       Result |       Lost |       ms |       inc/ms
-----------------|--------------|------------|----------|-------------
plain int        |      1284471 |    2715529 |       31 |        41434   <-- INCORRECT
volatile         |      1893204 |    2106796 |      142 |        13332   <-- INCORRECT
synchronized     |      4000000 |          0 |      213 |        18779
ReentrantLock    |      4000000 |          0 |      205 |        19512

package com.nexussoftware.bibliotech.service;

import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

public class DoubleRoomBooking {

    /** Room with an intrinsic lock and an explicit lock, for the three versions. */
    static class MeetingRoom {
        final String id;
        final Object monitor = new Object();
        final ReentrantLock lock = new ReentrantLock();
        int bookings = 0;

        MeetingRoom(String id) { this.id = id; }
    }

    // ---------- 1. DEADLOCKING VERSION ----------

    static void bookWrong(MeetingRoom a, MeetingRoom b) {
        synchronized (a.monitor) {
            pause(100);                     // widens the failure window
            synchronized (b.monitor) {
                a.bookings++;
                b.bookings++;
            }
        }
    }

    // ---------- 2. GLOBAL ACQUISITION ORDER ----------

    /**
     * The locks are ALWAYS taken in increasing order of 'id'.
     * With no circular wait there can be no deadlock: it is a
     * structural guarantee, not a probability.
     */
    static void bookRight(MeetingRoom a, MeetingRoom b) {
        MeetingRoom first  = a.id.compareTo(b.id) <= 0 ? a : b;
        MeetingRoom second = (first == a) ? b : a;

        synchronized (first.monitor) {
            pause(1);
            synchronized (second.monitor) {
                a.bookings++;
                b.bookings++;
            }
        }
    }

    // ---------- 3. TRYLOCK WITH RANDOM BACKOFF ----------

    static int bookWithTryLock(MeetingRoom a, MeetingRoom b, int maxAttempts)
            throws InterruptedException {

        for (int attempt = 1; attempt <= maxAttempts; attempt++) {
            boolean haveA = false, haveB = false;
            try {
                haveA = a.lock.tryLock(50, TimeUnit.MILLISECONDS);
                if (haveA) {
                    haveB = b.lock.tryLock(50, TimeUnit.MILLISECONDS);
                }
                if (haveA && haveB) {
                    a.bookings++;
                    b.bookings++;
                    return attempt;                  // success: return the attempt
                }
            } finally {
                if (haveB) b.lock.unlock();
                if (haveA) a.lock.unlock();
            }
            // RANDOM backoff: without it, two threads in phase would retry
            // together forever (livelock, section 12).
            TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextInt(5, 40));
        }
        return -1;                                    // not achieved
    }

    // ---------- DEMONSTRATION ----------

    public static void main(String[] args) throws InterruptedException {

        // --- 1. Provoke the deadlock ---
        System.out.println("=== 1. DEADLOCKING VERSION ===");
        MeetingRoom r1 = new MeetingRoom("ROOM-A");
        MeetingRoom r2 = new MeetingRoom("ROOM-B");

        Thread t1 = new Thread(() -> bookWrong(r1, r2), "thread-A-B");
        Thread t2 = new Thread(() -> bookWrong(r2, r1), "thread-B-A");
        t1.start(); t2.start();
        t1.join(3000); t2.join(3000);

        if (t1.isAlive() || t2.isAlive()) {
            System.out.println("  DEADLOCKED. t1=" + t1.getState()
                    + "  t2=" + t2.getState());
            System.out.println("  (jstack would say: Found one Java-level deadlock)");
        } else {
            System.out.println("  It did not happen this time; try again. "
                    + "The intermittency is exactly the problem.");
        }

        // --- 2. Global ordering: 1,000 attempts with 8 threads ---
        System.out.println();
        System.out.println("=== 2. GLOBAL ACQUISITION ORDER ===");
        MeetingRoom a = new MeetingRoom("ROOM-A");
        MeetingRoom b = new MeetingRoom("ROOM-B");

        Thread[] threads = new Thread[8];
        for (int i = 0; i < 8; i++) {
            final boolean forward = (i % 2 == 0);
            threads[i] = new Thread(() -> {
                for (int k = 0; k < 125; k++) {
                    if (forward) bookRight(a, b);
                    else         bookRight(b, a);      // opposite direction
                }
            }, "booker-" + i);
            threads[i].start();
        }
        for (Thread t : threads) t.join(20_000);

        boolean anyoneAlive = false;
        for (Thread t : threads) anyoneAlive |= t.isAlive();

        System.out.println("  Bookings ROOM-A: " + a.bookings);
        System.out.println("  Bookings ROOM-B: " + b.bookings);
        System.out.println("  Any thread blocked: " + anyoneAlive);
        System.out.println(anyoneAlive ? "  FAILURE" : "  CORRECT: 1,000 bookings with no deadlock");

        // --- 3. tryLock with backoff ---
        System.out.println();
        System.out.println("=== 3. TRYLOCK WITH RANDOM BACKOFF ===");
        MeetingRoom c = new MeetingRoom("ROOM-C");
        MeetingRoom d = new MeetingRoom("ROOM-D");

        AtomicInteger totalRetries = new AtomicInteger();
        AtomicInteger failures = new AtomicInteger();

        Thread[] ts = new Thread[4];
        for (int i = 0; i < 4; i++) {
            final boolean forward = (i % 2 == 0);
            ts[i] = new Thread(() -> {
                for (int k = 0; k < 50; k++) {
                    try {
                        int attempts = forward
                                ? bookWithTryLock(c, d, 10)
                                : bookWithTryLock(d, c, 10);
                        if (attempts < 0) failures.incrementAndGet();
                        else totalRetries.addAndGet(attempts - 1);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
            }, "trylock-" + i);
            ts[i].start();
        }
        for (Thread t : ts) t.join();

        System.out.println("  Bookings ROOM-C   : " + c.bookings);
        System.out.println("  Bookings ROOM-D   : " + d.bookings);
        System.out.println("  Total retries     : " + totalRetries.get());
        System.out.println("  Failures          : " + failures.get());
        System.out.println("  (the retries are the price of not imposing an order)");
    }

    static void pause(long ms) {
        try { TimeUnit.MILLISECONDS.sleep(ms); }
        catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }
}

=== 1. DEADLOCKING VERSION ===
  DEADLOCKED. t1=BLOCKED  t2=BLOCKED
  (jstack would say: Found one Java-level deadlock)

=== 2. GLOBAL ACQUISITION ORDER ===
  Bookings ROOM-A: 1000
  Bookings ROOM-B: 1000
  Any thread blocked: false
  CORRECT: 1,000 bookings with no deadlock

=== 3. TRYLOCK WITH RANDOM BACKOFF ===
  Bookings ROOM-C   : 200
  Bookings ROOM-D   : 200
  Total retries     : 37
  Failures          : 0

package com.nexussoftware.bibliotech.service;

import com.nexussoftware.bibliotech.domain.Card;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Thread-safe card cache, optimised for reading.
 *
 * POLICY: all the state is guarded by 'lock'.
 * Lookups that hit use the READ lock (shared);
 * only misses escalate to the WRITE lock (exclusive).
 */
public class SafeCardCache {

    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock  read  = lock.readLock();
    private final ReentrantReadWriteLock.WriteLock write = lock.writeLock();

    /** Guarded by 'lock'. */
    private final Map<String, Card> cache = new HashMap<>();
    /** Guarded by 'lock'. */
    private long hits = 0;
    private long misses = 0;

    public Card get(String isbn) {

        // PHASE 1: optimistic attempt with the SHARED lock.
        // Several threads can be here at once, which is 96% of the traffic.
        read.lock();
        try {
            Card c = cache.get(isbn);
            if (c != null) {
                // CAREFUL: 'hits++' under the READ lock would be a
                // race: several simultaneous readers would do
                // read-modify-write at once. We count it in phase 2.
                return c;
            }
        } finally {
            read.unlock();
        }

        // PHASE 2: a miss. We compute OUTSIDE any lock (rule 2 of
        // section 9: never slow operations inside a lock).
        Card computed = compute(isbn);

        // PHASE 3: publication with the EXCLUSIVE lock.
        write.lock();
        try {
            // We re-check: between phase 1 and phase 3 another thread may
            // have computed the same card. putIfAbsent keeps the first one
            // and preserves the consistency of the counts.
            Card alreadyThere = cache.putIfAbsent(isbn, computed);
            if (alreadyThere != null) {
                hits++;                      // another thread beat us to it
                return alreadyThere;
            }
            misses++;
            return computed;
        } finally {
            write.unlock();
        }
    }

    public void invalidate(String isbn) {
        write.lock();
        try { cache.remove(isbn); }
        finally { write.unlock(); }
    }

    public int size() {
        read.lock();
        try { return cache.size(); }
        finally { read.unlock(); }
    }

    public String statistics() {
        read.lock();
        try {
            long total = hits + misses;
            return String.format("hits=%d misses=%d rate=%.1f%%",
                    hits, misses, total == 0 ? 0.0 : 100.0 * hits / total);
        } finally {
            read.unlock();
        }
    }

    /** Simulates the real cost of building a card (query + formatting). */
    private Card compute(String isbn) {
        try { TimeUnit.MILLISECONDS.sleep(20); }
        catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        return new Card(isbn, "Title of " + isbn, "Author", 3);
    }

    // ---------- CONTRAST VERSION: a single exclusive lock ----------

    public static class SynchronizedCardCache {
        private final Map<String, Card> cache = new HashMap<>();

        // The WHOLE method synchronized, INCLUDING the 20 ms computation.
        // It is the mistake of rule 2 of section 9, on purpose.
        public synchronized Card get(String isbn) {
            Card c = cache.get(isbn);
            if (c == null) {
                try { TimeUnit.MILLISECONDS.sleep(20); }
                catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                c = new Card(isbn, "Title of " + isbn, "Author", 3);
                cache.put(isbn, c);
            }
            return c;
        }

        public synchronized int size() { return cache.size(); }
    }

    // ---------- TEST ----------

    public static void main(String[] args) throws InterruptedException {

        final int THREADS = 10;
        final int LOOKUPS = 2_000;
        final int ISBNS = 50;

        // --- ReadWriteLock version ---
        SafeCardCache rw = new SafeCardCache();
        long msRw = run(THREADS, LOOKUPS, ISBNS, isbn -> rw.get(isbn));

        System.out.println("=== ReadWriteLock ===");
        System.out.println("  Time     : " + msRw + " ms");
        System.out.println("  Entries  : " + rw.size());
        System.out.println("  " + rw.statistics());

        // --- Fully synchronized version ---
        SynchronizedCardCache sy = new SynchronizedCardCache();
        long msSy = run(THREADS, LOOKUPS, ISBNS, isbn -> sy.get(isbn));

        System.out.println();
        System.out.println("=== fully synchronized ===");
        System.out.println("  Time     : " + msSy + " ms");
        System.out.println("  Entries  : " + sy.size());

        System.out.println();
        System.out.printf("Ratio: %.1fx in favour of the ReadWriteLock%n",
                (double) msSy / msRw);
    }

    interface Lookup { Card get(String isbn); }

    static long run(int threads, int lookups, int isbns, Lookup l)
            throws InterruptedException {
        Thread[] ts = new Thread[threads];
        long start = System.nanoTime();
        for (int i = 0; i < threads; i++) {
            ts[i] = new Thread(() -> {
                for (int k = 0; k < lookups; k++) {
                    l.get("978-" + String.format("%010d", k % isbns));
                }
            }, "lookup-" + i);
            ts[i].start();
        }
        for (Thread t : ts) t.join();
        return (System.nanoTime() - start) / 1_000_000;
    }
}

=== ReadWriteLock ===
  Time     : 152 ms
  Entries  : 50
  hits=19 misses=50 rate=27.5%

=== fully synchronized ===
  Time     : 1043 ms
  Entries  : 50

Ratio: 6.9x in favour of the ReadWriteLock