class Transfers {
    static void transfer(Account from, Account to, long amount) {
        if (from.id == to.id) throw new IllegalArgumentException("same account");
        Account first  = from.id < to.id ? from : to;      // one global order: by id
        Account second = from.id < to.id ? to : from;
        synchronized (first) {
            synchronized (second) {
                if (from.balance < amount) throw new IllegalStateException("insufficient funds");
                from.balance -= amount;
                to.balance += amount;
            }
        }
    }
}
class Account {
    final long id;
    long balance;          // guarded by this
    Account(long id, long balance) { this.id = id; this.balance = balance; }
}

boolean transferWithRetry(Account from, Account to, long amount) throws InterruptedException {
    for (int attempt = 0; attempt < 5; attempt++) {
        if (from.lock.tryLock(50, TimeUnit.MILLISECONDS)) {
            try {
                if (to.lock.tryLock(50, TimeUnit.MILLISECONDS)) {
                    try {
                        from.balance -= amount; to.balance += amount;
                        return true;
                    } finally { to.lock.unlock(); }
                }
            } finally { from.lock.unlock(); }
        }
        Thread.sleep(ThreadLocalRandom.current().nextLong(5, 50));   // random back-off breaks lockstep
    }
    return false;    // report "busy, try again" to the caller
}

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

public class TryLockTransfers {
    static final class Account { long balance; final ReentrantLock lock = new ReentrantLock(); Account(long b) { balance = b; } }
    static final AtomicInteger retries = new AtomicInteger();

    static void transfer(Account from, Account to, long amt) throws InterruptedException {
        while (true) {
            if (from.lock.tryLock(10, TimeUnit.MILLISECONDS)) {
                try {
                    if (to.lock.tryLock(10, TimeUnit.MILLISECONDS)) {
                        try { from.balance -= amt; to.balance += amt; return; }
                        finally { to.lock.unlock(); }
                    }
                } finally {
                    from.lock.unlock();                    // on failure, release the first lock too: breaks "no preemption"
                }
            }
            retries.incrementAndGet();
            Thread.sleep(ThreadLocalRandom.current().nextLong(1, 5));   // random back-off: no livelock
        }
    }

    public static void main(String[] args) throws Exception {
        Account a = new Account(1_000), b = new Account(1_000);
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Future<?> f1 = pool.submit(() -> { for (int i = 0; i < 10_000; i++) transfer(a, b, 1); return null; });
        Future<?> f2 = pool.submit(() -> { for (int i = 0; i < 10_000; i++) transfer(b, a, 1); return null; });
        f1.get(60, TimeUnit.SECONDS);
        f2.get(60, TimeUnit.SECONDS);
        pool.shutdown();
        System.out.println("done: 20000 transfers, total = " + (a.balance + b.balance) + ", retries = " + retries.get());
    }
}

import java.util.concurrent.*;

public class PoolStarvation {
    public static void main(String[] args) throws Exception {
        ExecutorService single = Executors.newSingleThreadExecutor();
        Future<String> outer = single.submit(() -> {
            Future<String> inner = single.submit(() -> "inner result");   // queued behind us
            return inner.get(1, TimeUnit.SECONDS);                       // the only thread waits for itself
        });
        try {
            System.out.println(outer.get());
        } catch (ExecutionException e) {
            System.out.println("outer failed: " + e.getCause().getClass().getSimpleName() + ", inner task could not run while outer waited");
        }
        single.shutdownNow();
    }
}

Found one Java-level deadlock:
=============================
"transfer-1":
  waiting to lock monitor 0x00007f3c2c003f88 (object 0x000000071a8c2d30, a Account),
  which is held by "transfer-2"
"transfer-2":
  waiting to lock monitor 0x00007f3c2c006a18 (object 0x000000071a8c2d18, a Account),
  which is held by "transfer-1"

Java stack information for the threads listed above:
===================================================
"transfer-1":
        at NaiveTransfers.transfer(NaiveTransfers.java:9)
        - waiting to lock <0x000000071a8c2d30> (a Account)
        - locked <0x000000071a8c2d18> (a Account)

import java.lang.management.*;

public class DeadlockDetector {
    public static void main(String[] args) throws Exception {
        Object a = new Object(), b = new Object();
        start("transfer-1", a, b);
        start("transfer-2", b, a);                      // opposite order: deadlock
        Thread.sleep(300);

        ThreadMXBean mx = ManagementFactory.getThreadMXBean();
        long[] ids = mx.findDeadlockedThreads();        // monitors and ReentrantLocks, platform threads only
        if (ids != null) {
            for (ThreadInfo info : mx.getThreadInfo(ids))
                System.out.println("deadlocked: " + info.getThreadName() + " waiting for " + info.getLockName());
        }
    }

    static void start(String name, Object first, Object second) {
        Thread t = new Thread(() -> {
            synchronized (first) {
                sleep(100);
                synchronized (second) { System.out.println("never printed"); }
            }
        }, name);
        t.setDaemon(true);                              // lets the demo JVM exit
        t.start();
    }
    static void sleep(long ms) { try { Thread.sleep(ms); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }
}

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Formatters {
    static final SimpleDateFormat SHARED = new SimpleDateFormat("yyyy-MM-dd");         // NOT thread-safe
    static final DateTimeFormatter SAFE = DateTimeFormatter.ofPattern("yyyy-MM-dd");   // immutable, thread-safe

    public static void main(String[] args) throws Exception {
        List<String> dates = new ArrayList<>();
        for (int d = 1; d <= 28; d++) dates.add(String.format("2026-02-%02d", d));
        AtomicInteger badOld = new AtomicInteger(), badNew = new AtomicInteger();
        ExecutorService pool = Executors.newFixedThreadPool(8);
        for (int i = 0; i < 20_000; i++) {
            String s = dates.get(i % dates.size());
            pool.execute(() -> {
                try {
                    String back = new SimpleDateFormat("yyyy-MM-dd").format(SHARED.parse(s));
                    if (!back.equals(s)) badOld.incrementAndGet();
                } catch (Exception e) {
                    badOld.incrementAndGet();                                      // garbled state often throws
                }
                if (!LocalDate.parse(s, SAFE).format(SAFE).equals(s)) badNew.incrementAndGet();
            });
        }
        pool.shutdown();
        pool.awaitTermination(30, TimeUnit.SECONDS);
        System.out.println("shared SimpleDateFormat wrong results: " + badOld.get() + " (often > 0 on multicore machines)");
        System.out.println("DateTimeFormatter wrong results: " + badNew.get());
    }
}

final class RequestContext {
    private static final ThreadLocal<String> USER = new ThreadLocal<>();
    private static final ThreadLocal<MessageDigest> SHA256 = ThreadLocal.withInitial(() -> {
        try { return MessageDigest.getInstance("SHA-256"); }      // not thread-safe: one per thread
        catch (NoSuchAlgorithmException e) { throw new IllegalStateException(e); }
    });

    static void setUser(String user) { USER.set(user); }
    static String user() { return USER.get(); }                    // null if never set on this thread
    static void clear() { USER.remove(); }                         // remove, not set(null)

    static byte[] hash(byte[] data) { return SHA256.get().digest(data); }

    private RequestContext() { }
}

import java.util.concurrent.*;

public class ThreadLocalLeak {
    static final ThreadLocal<String> USER = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newSingleThreadExecutor();     // one reused thread, like a busy server

        pool.submit(() -> { USER.set("alice"); /* handle request 1, forget to clean up */ }).get();
        pool.submit(() -> System.out.println("request 2 sees user: " + USER.get())).get();

        pool.submit(() -> {
            USER.set("bob");
            try {
                /* handle request 3 */
            } finally {
                USER.remove();                                           // the fix: always clean up
            }
        }).get();
        pool.submit(() -> System.out.println("request 4 sees user: " + USER.get())).get();
        pool.shutdown();
    }
}

request 2 sees user: alice
request 4 sees user: null

final class ContextAwareExecutor implements Executor {
    static final ThreadLocal<String> TRACE_ID = new ThreadLocal<>();
    private final Executor delegate;
    ContextAwareExecutor(Executor delegate) { this.delegate = delegate; }

    @Override public void execute(Runnable task) {
        String captured = TRACE_ID.get();          // runs on the submitting thread
        delegate.execute(() -> {
            String previous = TRACE_ID.get();
            TRACE_ID.set(captured);                // runs on the worker thread
            try {
                task.run();
            } finally {
                if (previous == null) TRACE_ID.remove(); else TRACE_ID.set(previous);
            }
        });
    }
}

import java.util.concurrent.*;

public class TraceDemo {
    static final ThreadLocal<String> TRACE = new ThreadLocal<>();

    static Runnable withTrace(Runnable task) {
        String captured = TRACE.get();                        // runs on the submitting thread
        return () -> {                                        // runs on the worker thread
            String previous = TRACE.get();                    // null on a clean pool thread
            TRACE.set(captured);
            try { task.run(); }
            finally {                                         // never leak into the next task, and stay safe
                if (previous == null) TRACE.remove();         // when the task runs on the caller's own thread
                else TRACE.set(previous);                     // (CallerRunsPolicy, a direct executor)
            }
        };
    }
    static void log(String msg) { System.out.println("[trace=" + TRACE.get() + "] " + msg); }

    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        TRACE.set("req-42");                                  // a web filter does this in real code
        try {
            log("handling request");
            pool.submit(() -> log("plain task")).get();               // lost: a different thread
            pool.submit(withTrace(() -> log("wrapped task"))).get();  // carried over
        } finally {
            TRACE.remove();                                   // the filter clears it at the end of the request
        }
        pool.shutdown();
    }
}

static final ScopedValue<String> TENANT = ScopedValue.newInstance();

void handle(Request req) {
    ScopedValue.where(TENANT, req.tenantId())     // bound only for the duration of run()
               .run(() -> service.process(req));  // anything called inside can read TENANT.get()
}                                                 // unbound again here: nothing to remove, nothing to leak

import java.time.Duration;
import java.util.concurrent.*;

public class TenThousand {
    public static void main(String[] args) {
        long start = System.nanoTime();
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {   // one new virtual thread per task
            for (int i = 0; i < 10_000; i++) {
                exec.submit(() -> {
                    Thread.sleep(Duration.ofSeconds(1));      // blocking is fine: the carrier is released
                    return null;
                });
            }
        }                                                     // close() waits for all tasks
        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.println("10000 tasks finished in " + ms + " ms");   // about 1 second, not 10,000
    }
}

class PartnerGateway {
    private final Semaphore concurrent = new Semaphore(20);    // partner allows 20 parallel calls

    Response call(Request req) throws InterruptedException {
        if (!concurrent.tryAcquire(500, TimeUnit.MILLISECONDS)) throw new IllegalStateException("partner busy");
        try {
            return http.send(req);          // blocking is fine on a virtual thread
        } finally {
            concurrent.release();
        }
    }
    interface Http { Response send(Request r); }
    record Request(String body) { }
    record Response(int status) { }
    private final Http http = r -> new Response(200);
}

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class LimitedFanOut {
    public static void main(String[] args) {
        Semaphore dbSlots = new Semaphore(50);                    // the database can take 50 concurrent queries
        AtomicInteger inUse = new AtomicInteger(), peak = new AtomicInteger();
        long start = System.nanoTime();
        try (ExecutorService vt = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 1_000; i++) {
                vt.submit(() -> {
                    dbSlots.acquire();                            // waiting parks the virtual thread cheaply
                    try {
                        peak.accumulateAndGet(inUse.incrementAndGet(), Math::max);
                        Thread.sleep(20);                         // the query
                    } finally {
                        inUse.decrementAndGet();
                        dbSlots.release();
                    }
                    return null;
                });
            }
        }
        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.println("1000 queries, peak concurrent = " + peak.get() + ", about " + ms + " ms");   // 20 waves of 20 ms
    }
}

import java.util.concurrent.*;

public class ParallelSum extends RecursiveTask<Long> {
    private static final int THRESHOLD = 100_000;            // below this, just loop
    private final long[] data; private final int from, to;

    ParallelSum(long[] data, int from, int to) { this.data = data; this.from = from; this.to = to; }

    @Override protected Long compute() {
        if (to - from <= THRESHOLD) {
            long sum = 0;
            for (int i = from; i < to; i++) sum += data[i];
            return sum;
        }
        int mid = (from + to) >>> 1;
        ParallelSum left = new ParallelSum(data, from, mid);
        ParallelSum right = new ParallelSum(data, mid, to);
        left.fork();                                          // push left; another worker may steal it
        long r = right.compute();                             // do the right half ourselves
        return left.join() + r;                               // join may run other tasks while waiting
    }

    public static void main(String[] args) {
        long[] data = new long[10_000_000];
        java.util.Arrays.fill(data, 2);
        long total = ForkJoinPool.commonPool().invoke(new ParallelSum(data, 0, data.length));
        System.out.println("sum = " + total);
    }
}

import java.util.stream.LongStream;

public class ParallelStreams {
    public static void main(String[] args) {
        long n = 50_000_000;
        for (int round = 1; round <= 3; round++) {             // round 1 includes JIT warm-up: trust the later rounds
            long t0 = System.nanoTime();
            long seq = LongStream.rangeClosed(1, n).map(x -> x % 7).sum();
            long t1 = System.nanoTime();
            long par = LongStream.rangeClosed(1, n).parallel().map(x -> x % 7).sum();   // split across the common pool
            long t2 = System.nanoTime();
            System.out.println("round " + round + ": same result: " + (seq == par)
                    + ", sequential " + (t1 - t0) / 1_000_000 + " ms, parallel " + (t2 - t1) / 1_000_000 + " ms");
        }
    }
}