Java线上死锁问题从定位到解决的全链路指南

# 方式1：使用jps快速定位
$ jps -l
12345 com.example.OrderServiceApplication

# 方式2：通过进程名过滤
$ ps -ef | grep java | grep -v grep
appuser  12345     1  5 Jun19 ?  02:10:35 java -Xmx2g -jar order-service.jar

# 生成带时间戳的转储文件
$ jstack -l 12345 > jstack_$(date +%Y%m%d_%H%M%S).log

# 生产环境推荐完整保存现场
$ mkdir -p /var/crash/$(date +%Y%m%d)
$ jstack -l 12345 > /var/crash/$(date +%Y%m%d)/thread_dump.log
$ jmap -dump:live,format=b,file=/var/crash/$(date +%Y%m%d)/heap.hprof 12345

# 优雅关闭（Spring Boot应用）
$ kill -15 12345 

# 强制关闭（当优雅关闭失效时）
$ kill -9 12345

# 容器化环境重启
$ kubectl rollout restart deployment/order-service

$ grep -A 30 "deadlock" jstack_20230619_142030.log

# 输出示例
Found one Java-level deadlock:
=============================
"Order-Processor-Thread-2":
  waiting to lock monitor 0x00007fdd6c0078a8 (object 0x00000000ff8e6c20),
  which is held by "Order-Processor-Thread-1"
"Order-Processor-Thread-1":
  waiting to lock monitor 0x00007fdd6c007658 (object 0x00000000ff8e6c30),
  which is held by "Order-Processor-Thread-2"

"Order-Processor-Thread-1" #12 prio=5 os_prio=0 tid=0x00007fdd6c0078a8 
  java.lang.Thread.State: BLOCKED (on object monitor)
  at com.example.OrderService.deductStock(OrderService.java:42)
  - waiting to lock <0x00000000ff8e6c30> 
  - locked <0x00000000ff8e6c20> 

"Order-Processor-Thread-2" #13 prio=5 os_prio=0 tid=0x00007fdd6c007658 
  at com.example.UserService.updateCredit(UserService.java:35)
  - waiting to lock <0x00000000ff8e6c20> 
  - locked <0x00000000ff8e6c30>

// 锁管理器：通过哈希强制排序
public class LockSequencer {
    public static List<Object> sortLocks(Object... locks) {
        return Arrays.stream(locks)
                   .sorted(Comparator.comparingInt(System::identityHashCode))
                   .collect(Collectors.toList());
    }
}

// 业务代码应用
public void processOrder(Order order, User user) {
    List<Object> orderedLocks = LockSequencer.sortLocks(orderLock, userLock);
    
    synchronized(orderedLocks.get(0)) {
        synchronized(orderedLocks.get(1)) {
            // 业务操作
            deductStock(order);
            updateCredit(user);
        }
    }
}

// 基于ReentrantLock的带超时锁
public class SafeLockManager {
    private final ReentrantLock orderLock = new ReentrantLock();
    private final ReentrantLock userLock = new ReentrantLock();
    
    private static final long LOCK_TIMEOUT = 500; // 毫秒

    public boolean tryProcessOrder(Order order, User user) {
        boolean orderLocked = false;
        boolean userLocked = false;
        
        try {
            // 尝试获取第一个锁（带超时）
            orderLocked = orderLock.tryLock(LOCK_TIMEOUT, TimeUnit.MILLISECONDS);
            if (!orderLocked) return false;

            // 尝试获取第二个锁（带超时）
            userLocked = userLock.tryLock(LOCK_TIMEOUT, TimeUnit.MILLISECONDS);
            if (!userLocked) return false;

            // 执行核心业务
            return executeBusiness(order, user);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            // 按获取的逆序释放锁
            if (userLocked) userLock.unlock();
            if (orderLocked) orderLock.unlock();
        }
    }
    
    // 业务失败补偿机制
    private void rollback(Order order, User user) {
        // 实现回滚逻辑
    }
}

@Configuration
public class DeadlockMonitorConfig {

    @Bean
    public ScheduledExecutorService deadlockMonitor() {
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(() -> {
            ThreadMXBean bean = ManagementFactory.getThreadMXBean();
            long[] deadlockedThreads = bean.findDeadlockedThreads();
            
            if (deadlockedThreads != null) {
                // 发送报警通知
                AlertManager.sendCriticalAlert("DEADLOCK_DETECTED", 
                    "Deadlocked threads: " + Arrays.toString(deadlockedThreads));
                
                // 自动保存诊断信息
                ThreadDumpUtil.saveDiagnosticData();
            }
        }, 1, 5, TimeUnit.MINUTES); // 每5分钟检测
        return scheduler;
    }
}

# 启动实时死锁监控
$ thread -b -i 10

# 监控锁竞争热点
$ monitor -c 5 java.util.concurrent.locks.ReentrantLock lock

// 使用ChaosBlade注入延迟
@ChaosExperiment
public void simulateDeadlockScenario() {
    // 在锁获取时注入延迟
    ChaosBlade.setDelay("java.util.concurrent.locks.ReentrantLock", "lock", 1000);
    
    // 执行并发测试
    runConcurrentTest();
}

// 使用资源排序+tryLock混合方案
public void processOrder(Order order, User user) {
    List<Lock> locks = Arrays.asList(orderLock, userLock);
    locks.sort(LockComparator.INSTANCE);
    
    for (Lock lock : locks) {
        if (!lock.tryLock(300, TimeUnit.MILLISECONDS)) {
            rollback(order, user);
            throw new BusyException("系统繁忙，请重试");
        }
    }
    
    try {
        // 业务处理
    } finally {
        // 逆序释放
        Collections.reverse(locks).forEach(Lock::unlock);
    }
}