#死锁排查与解决

// jstack死锁输出示例
Found one deadlock:
=========================

"pool-1-thread-1":
  waiting for monitor entry [0x00007f8a4c02a800]
  at com.example.service.AccountService.transfer(AccountService.java:45)
  - waiting to lock <0x00000007d8a01234> (a java.lang.Object)
  - locked <0x00000007d8a05678> (a java.lang.Object)

"pool-1-thread-2":
  waiting for monitor entry [0x00007f8a4c02a800]
  at com.example.service.AccountService.transfer(AccountService.java:65)
  - waiting to lock <0x00000007d8a05678> (a java.lang.Object)
  - locked <0x00000007d8a01234> (a java.lang.Object)

// 死锁分析示例
线程A：
  locked obj1
  waiting for obj2

线程B：
  locked obj2
  waiting for obj1

等待图：
obj1 → [A] → waiting → obj2 → [B] → locked → obj1
           ↑                                   ↓
           └───────────────────────────────────┘

这就是循环等待！

// 错误代码
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    // 按不同顺序加锁，导致死锁
    if (fromId < toId) {
        lock(fromId);
        lock(toId);
    } else {
        lock(toId);
        lock(fromId);  // 可能和另一个线程形成死锁
    }

    try {
        Account from = accountDAO.selectById(fromId);
        Account to = accountDAO.selectById(toId);
        from.setBalance(from.getBalance().subtract(amount));
        to.setBalance(to.getBalance().add(amount));
        accountDAO.update(from);
        accountDAO.update(to);
    } finally {
        unlock(toId);
        unlock(fromId);
    }
}

// 正确代码：统一加锁顺序
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    // 统一按ID大小顺序加锁
    Long firstId = fromId < toId ? fromId : toId;
    Long secondId = fromId < toId ? toId : fromId;

    lock(firstId);
    lock(secondId);

    try {
        Account from = accountDAO.selectById(fromId);
        Account to = accountDAO.selectById(toId);
        from.setBalance(from.getBalance().subtract(amount));
        to.setBalance(to.getBalance().add(amount));
        accountDAO.update(from);
        accountDAO.update(to);
    } finally {
        unlock(secondId);
        unlock(firstId);
    }
}

// MySQL死锁场景
// 事务A
UPDATE orders SET status='PAID' WHERE id=1;
UPDATE orders SET status='PAID' WHERE id=2;

// 事务B
UPDATE orders SET status='PAID' WHERE id=2;  // 和A的第二个语句冲突
UPDATE orders SET status='PAID' WHERE id=1;  // 和A的第一个语句冲突

// 解决方案：按固定顺序更新
UPDATE orders SET status='PAID' WHERE id IN (1, 2) ORDER BY id;

// 错误代码：嵌套锁
public void methodA() {
    synchronized(lock1) {
        methodB();
    }
}

public void methodB() {
    synchronized(lock2) {  // 如果另一个线程先调用methodB再调用methodA
        // ...
    }
}

// 解决方案1：不要嵌套加锁
public void methodA() {
    lock(lock1);
    try {
        // 直接调用不需要锁的逻辑
        doMethodA();
    } finally {
        unlock(lock1);
    }
}

// 解决方案2：按固定顺序加锁
public void methodA() {
    if (System.identityHashCode(lock1) < System.identityHashCode(lock2)) {
        lock(lock1);
        lock(lock2);
    } else {
        lock(lock2);
        lock(lock1);
    }
}

// ReentrantLock带超时
private final ReentrantLock lock = new ReentrantLock();

public void doSomething() {
    try {
        // 尝试获取锁，等待最多3秒
        if (lock.tryLock(3, TimeUnit.SECONDS)) {
            try {
                // 业务逻辑
            } finally {
                lock.unlock();
            }
        } else {
            // 获取锁失败，超时处理
            log.warn("获取锁超时，回滚操作");
            rollback();
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        rollback();
    }
}

// 定期检测死锁
public class DeadlockDetector {

    public void detect() {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();

        if (deadlockedThreads != null && deadlockedThreads.length > 0) {
            ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(deadlockedThreads);
            for (ThreadInfo info : threadInfos) {
                log.error("检测到死锁: {}", info.getThreadName());
            }
            // 发送告警
            alertService.sendAlert("检测到死锁！");
        }
    }
}