《Java 并发编程·性能诊断与事故》4.3 锁顺序规范与超时兜底

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

public final class OrderedTransfer {
    private final ReentrantLock[] locks = new ReentrantLock[16];

    public OrderedTransfer() {
        for (int i = 0; i < locks.length; i++) {
            locks[i] = new ReentrantLock();
        }
    }

    public boolean transfer(int fromId, int toId, long amount, long timeoutMillis)
            throws InterruptedException {
        int firstId = Math.min(fromId, toId);
        int secondId = Math.max(fromId, toId);
        ReentrantLock first = locks[firstId];
        ReentrantLock second = locks[secondId];
        if (!first.tryLock(timeoutMillis, TimeUnit.MILLISECONDS)) {
            return false;
        }
        try {
            if (!second.tryLock(timeoutMillis, TimeUnit.MILLISECONDS)) {
                return false;                  // finally 会释放 first
            }
            try {
                if (firstId == fromId) {
                    debit(firstId, amount);
                    credit(secondId, amount);
                } else {
                    debit(secondId, amount);
                    credit(firstId, amount);
                }
                return true;
            } finally {
                second.unlock();
            }
        } finally {
            first.unlock();
        }
    }

    private void debit(int id, long amount) {
    }

    private void credit(int id, long amount) {
    }
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.ReentrantLock;

public final class OrderLab {
    private static final ReentrantLock LOCK_A = new ReentrantLock();
    private static final ReentrantLock LOCK_B = new ReentrantLock();
    private static final AtomicLong BOTH = new AtomicLong();
    private static final AtomicLong TIMEOUT = new AtomicLong();

    public static void main(String[] args) throws Exception {
        long millis = args.length > 0 ? Long.parseLong(args[0]) : 10_000;
        for (int i = 0; i < 4; i++) {
            boolean forward = i % 2 == 0;
            Thread.ofPlatform().name((forward ? "order-ab-" : "order-ba-") + i).start(() -> {
                long deadline = System.nanoTime() + millis * 1_000_000L;
                while (System.nanoTime() < deadline) {
                    ReentrantLock first = forward ? LOCK_A : LOCK_B;
                    ReentrantLock second = forward ? LOCK_B : LOCK_A;
                    first.lock();
                    boolean got = false;
                    try {
                        sleep(40);                 // 持有第一把锁时停一下，便于采样
                        try {
                            got = second.tryLock(100, TimeUnit.MILLISECONDS);
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            return;
                        }
                        if (got) {
                            BOTH.incrementAndGet();
                            sleep(20);
                        } else {
                            TIMEOUT.incrementAndGet();
                        }
                    } finally {
                        if (got) {
                            second.unlock();
                        }
                        first.unlock();
                    }
                }
            });
        }
        System.out.println("pid=" + ProcessHandle.current().pid());
        Thread.sleep(millis + 1000);
        System.out.printf("both=%d timeout=%d%n", BOTH.get(), TIMEOUT.get());
    }

    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

"order-ab-0" #25 ... 
   java.lang.Thread.State: TIMED_WAITING (parking)
	- parking to wait for  <0x000000035fc19610> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireNanos(...)

Found one Java-level deadlock:
=============================
"order-ab-0":
  waiting for ownable synchronizer 0x000000035fc19610, ...
  which is held by "order-ba-1"

"order-ba-1":
  waiting for ownable synchronizer 0x000000035fc195e0, ...
  which is held by "order-ab-0"

[watchdog] deadlocked=[25, 26]
[watchdog] deadlocked=none
[watchdog] deadlocked=[25, 26]
[watchdog] deadlocked=none

import java.util.concurrent.locks.ReentrantLock;

public final class HierarchicalLocks {
    private final ReentrantLock catalog = new ReentrantLock();   // L0：目录
    private final ReentrantLock[] buckets = new ReentrantLock[32]; // L1：分片

    public HierarchicalLocks() {
        for (int i = 0; i < buckets.length; i++) {
            buckets[i] = new ReentrantLock();
        }
    }

    public void update(String isbn) {
        int index;
        catalog.lock();                        // 先粗
        try {
            index = Math.floorMod(isbn.hashCode(), buckets.length);
        } finally {
            catalog.unlock();                  // 粗锁必须在拿细锁之前释放
        }
        buckets[index].lock();                 // 再细
        try {
            // 只操作该分片
        } finally {
            buckets[index].unlock();
        }
    }
}

python3 - out/dumps/*.txt <<'PY'
import re, sys
thread = re.compile(r'^"([^"]+)" #\d+ ')
lock = re.compile(r'^\s*-\s+(?:locked )?<(0x[0-9a-f]+)> \(a ')
wait = re.compile(r'-\s+(?:waiting to lock|parking to wait for)\s+<(0x[0-9a-f]+)>')
found = total = 0
for path in sys.argv[1:]:
    name, held, waits, edges = None, set(), set(), set()
    def flush():
        for h in held:
            for w in waits:
                if h != w:
                    edges.add((h, w))
    for line in open(path, encoding='utf-8', errors='replace'):
        m = thread.match(line)
        if m:
            flush()
            name, held, waits = m.group(1), set(), set()
            continue
        if name is None:
            continue
        m = lock.match(line)
        if m:
            held.add(m.group(1))
            continue
        m = wait.search(line)
        if m:
            waits.add(m.group(1))
    flush()
    reverse = {(h, w) for h, w in edges if (w, h) in edges}
    if reverse:
        found += 1
        print(path, 'reverse edges:', sorted(reverse))
    total += 1
print(f'scanned={total} dumps_with_reverse={found}')
PY