The balance that created money

import java.util.*;
import java.util.concurrent.*;

/**
 * Solution: the balance that created money.
 *
 * The defect was lock scope, not a missing lock. `synchronized void transfer`
 * locks `this`, so it guarded the debit and left the credit — a write to
 * ANOTHER object's field — completely unguarded. A transfer in the opposite
 * direction holds the other account's monitor, so the two never exclude each
 * other, and both balances are written concurrently.
 *
 * The fix has two halves, and the second is the one people miss:
 *
 *   1. A transfer touches two accounts, so it must hold both monitors. Two
 *      separately-correct locks do not make one correct operation.
 *   2. Acquiring both in call order deadlocks the moment two transfers run in
 *      opposite directions — each holds what the other needs. So they must be
 *      acquired in a consistent GLOBAL order. Account id is a natural one, and
 *      any total order works as long as every caller uses the same one.
 *
 * Note what is NOT needed: volatile on the balance. A field only read and
 * written while holding a monitor gets its visibility from the monitor.
 */
public class Solution {

    static final int THREADS = 8;
    static final int PER_THREAD = 100_000;
    static final long OPENING = 1_000_000L;

    static class Account {
        final int id;
        long balance;

        Account(int id, long balance) {
            this.id = id;
            this.balance = balance;
        }

        /**
         * FIX: hold both monitors, always in id order, so no two transfers can
         * acquire them in opposite sequences.
         */
        void transfer(Account to, long amount) {
            Account first = this.id < to.id ? this : to;
            Account second = this.id < to.id ? to : this;

            synchronized (first) {
                synchronized (second) {
                    if (balance < amount) return;
                    balance -= amount;
                    to.balance += amount;
                }
            }
        }

        long balance() {
            synchronized (this) {
                return balance;
            }
        }
    }

    public static void main(String[] args) throws Exception {
        boolean ok = true;

        Account a = new Account(1, OPENING);
        Account b = new Account(2, OPENING);
        long before = a.balance + b.balance;

        System.out.println("── " + THREADS + " threads x " + PER_THREAD + " transfers, both directions ──");

        Thread work = new Thread(() -> {
            try {
                hammer(a, b);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        work.start();
        work.join(30_000);

        boolean finished = !work.isAlive();
        if (!finished) {
            System.out.println("  still running after 30s — threads are stuck");
            work.interrupt();
        }

        long after = a.balance + b.balance;
        System.out.println("  opening total : " + before);
        System.out.println("  closing total : " + after);
        System.out.println("  difference    : " + (after - before));
        System.out.println("  account 1     : " + a.balance);
        System.out.println("  account 2     : " + b.balance);
        System.out.println();

        ok &= check("the run completed — nothing deadlocked", finished);
        ok &= check("total money is unchanged", after == before);
        ok &= check("no account ended negative", a.balance >= 0 && b.balance >= 0);

        System.out.println();
        System.out.println(ok ? "PASS" : "FAIL");
    }

    static void hammer(Account a, Account b) throws Exception {
        Thread[] threads = new Thread[THREADS];
        CountDownLatch start = new CountDownLatch(1);
        for (int i = 0; i < THREADS; i++) {
            Account from = (i % 2 == 0) ? a : b;
            Account to = (i % 2 == 0) ? b : a;
            threads[i] = new Thread(() -> {
                try {
                    start.await();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return;
                }
                for (int n = 0; n < PER_THREAD; n++) from.transfer(to, 1L);
            });
            threads[i].start();
        }
        start.countDown();
        for (Thread t : threads) t.join();
    }

    static boolean check(String what, boolean passed) {
        System.out.println((passed ? "  ok    " : "  FAIL  ") + what);
        return passed;
    }
}