Java编程中常见的六大死锁场景及其应对策略详解

// 线程1执行顺序
synchronized(lockA) {
    synchronized(lockB) {
        // 操作共享资源
    }
}

// 线程2执行顺序  
synchronized(lockB) {
    synchronized(lockA) {
        // 操作共享资源
    }
}

// 统一获取顺序示例
public void method1() {
    synchronized(lockA) {
        synchronized(lockB) {
            // 业务逻辑
        }
    }
}

public void method2() {
    synchronized(lockA) {
        synchronized(lockB) {
            // 业务逻辑
        }
    }
}

public void transfer(Account from, Account to, BigDecimal amount) {
    synchronized(from) {
        synchronized(to) {
            from.debit(amount);
            to.credit(amount);
        }
    }
}

public void transfer(Account from, Account to, BigDecimal amount) {
    Object firstLock = from;
    Object secondLock = to;
    
    if (System.identityHashCode(from) > System.identityHashCode(to)) {
        firstLock = to;
        secondLock = from;
    }
    
    synchronized(firstLock) {
        synchronized(secondLock) {
            from.debit(amount);
            to.credit(amount);
        }
    }
}

class CooperatingObject1 {
    public synchronized void method1(CooperatingObject2 obj2) {
        // ...
        obj2.method2();
    }
}

class CooperatingObject2 {
    public synchronized void method2() {
        // ...
    }
}

class CooperatingObject1 {
    public void method1(CooperatingObject2 obj2) {
        synchronized(this) {
            // 必要的同步操作
        }
        // 开放调用：不持有锁时调用外部方法
        obj2.method2();
    }
}

ExecutorService executor = Executors.newFixedThreadPool(1);
Future<String> future1 = executor.submit(() -> {
    Future<String> future2 = executor.submit(() -> "result");
    return future2.get(); // 等待内部任务完成
});
String result = future1.get(); // 死锁！

// 使用缓存线程池或足够大的固定大小线程池
ExecutorService executor = Executors.newCachedThreadPool();

// 使用单线程Executor
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(() -> {
    // 这个任务需要等待另一个任务完成
    Future<String> innerFuture = executor.submit(() -> "done");
    return innerFuture.get(); // 死锁！
});

class CustomLock {
    private boolean isLocked = false;
    
    public synchronized void lock() throws InterruptedException {
        while(isLocked) {
            wait();
        }
        isLocked = true;
    }
    
    public synchronized void unlock() {
        isLocked = false;
        notify();
    }
}

// 使用Java提供的可重入锁
ReentrantLock lock = new ReentrantLock();
public void method() {
    lock.lock();
    try {
        // 可重入：同一线程可以再次获取锁
        nestedMethod();
    } finally {
        lock.unlock();
    }
}

private void nestedMethod() {
    lock.lock();
    try {
        // 业务逻辑
    } finally {
        lock.unlock();
    }
}