#死锁故障实战复盘

// 死锁示例：转账场景
@Service
public class TransferService {

    private final Object lockA = new Object();
    private final Object lockB = new Object();

    /**
     * 转账A→B
     */
    public void transferAtoB(BigDecimal amount) {
        synchronized (lockA) {  // T1: 持有lockA，等待lockB
            try { Thread.sleep(10); } catch (InterruptedException ignored) {}
            synchronized (lockB) {
                // 执行转账
            }
        }
    }

    /**
     * 转账B→A
     */
    public void transferBtoA(BigDecimal amount) {
        synchronized (lockB) {  // T2: 持有lockB，等待lockA
            try { Thread.sleep(10); } catch (InterruptedException ignored) {}
            synchronized (lockA) {
                // 执行转账
            }
        }
    }
}

// 死锁发生过程：
// T1调用transferAtoB，持有lockA
// T2调用transferBtoA，持有lockB
// T1尝试获取lockB，等待T2释放
// T2尝试获取lockA，等待T1释放
// 死锁形成！

// 预防死锁方案1：统一加锁顺序
@Service
public class SafeTransferService {

    private final ConcurrentHashMap<Long, Object> accountLocks =
        new ConcurrentHashMap<>();

    /**
     * 获取账户锁，按ID排序保证顺序一致
     */
    private Object getLock(Long accountId) {
        return accountLocks.computeIfAbsent(accountId, k -> new Object());
    }

    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        // 按ID排序，确保加锁顺序一致
        Long firstId = fromId.compareTo(toId) < 0 ? fromId : toId;
        Long secondId = fromId.compareTo(toId) < 0 ? toId : fromId;

        Object firstLock = getLock(firstId);
        Object secondLock = getLock(secondId);

        synchronized (firstLock) {
            synchronized (secondLock) {
                // 执行转账
                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);
            }
        }
    }
}

// 预防死锁方案2：使用ReentrantLock + tryLock
@Service
public class LockBasedTransferService {

    private final ConcurrentHashMap<Long, ReentrantLock> locks =
        new ConcurrentHashMap<>();

    private static final long LOCK_TIMEOUT = 3;  // 3秒超时

    public boolean transfer(Long fromId, Long toId, BigDecimal amount) {
        // 按ID排序
        Long firstId = fromId.compareTo(toId) < 0 ? fromId : toId;
        Long secondId = fromId.compareTo(toId) < 0 ? toId : fromId;

        ReentrantLock firstLock = locks.computeIfAbsent(firstId, k -> new ReentrantLock());
        ReentrantLock secondLock = locks.computeIfAbsent(secondId, k -> new ReentrantLock());

        boolean firstAcquired = firstLock.tryLock(LOCK_TIMEOUT, TimeUnit.SECONDS);
        if (!firstAcquired) {
            log.warn("获取锁[{}]超时，转账失败", firstId);
            return false;
        }

        try {
            boolean secondAcquired = secondLock.tryLock(LOCK_TIMEOUT, TimeUnit.SECONDS);
            if (!secondAcquired) {
                log.warn("获取锁[{}]超时，转账失败", secondId);
                return false;
            }

            try {
                // 执行转账
                doTransfer(fromId, toId, amount);
                return true;
            } finally {
                secondLock.unlock();
            }
        } finally {
            firstLock.unlock();
        }
    }
}

// 活锁示例：两个线程不断重试但都无法完成
public class LivelockExample {

    private final AtomicBoolean aliceTurn = new AtomicBoolean(true);

    public void aliceAction() {
        while (true) {
            if (aliceTurn.get()) {
                System.out.println("Alice: 等待Bob...");
                aliceTurn.set(false);  // 切换给Bob
                try { Thread.sleep(100); } catch (InterruptedException ignored) {}
            } else {
                // Alice执行
                System.out.println("Alice: 执行中...");
                aliceTurn.set(true);
                break;
            }
        }
    }
}

// 活锁特点：
// - 线程不会阻塞
// - 但也无法完成任务
// - 两个线程不断切换，谁都无法完成

// 解决活锁：添加随机退避
@Service
public class SafeLockService {

    private final Random random = new Random();

    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        int maxRetries = 3;
        for (int i = 0; i < maxRetries; i++) {
            try {
                doTransfer(fromId, toId, amount);
                return;
            } catch (Exception e) {
                log.warn("转账失败，重试第{}次", i + 1);
                // 随机退避，避免活锁
                try {
                    Thread.sleep(random.nextInt(100));
                } catch (InterruptedException ignored) {}
            }
        }
        throw new BizException("转账失败，已达到最大重试次数");
    }
}