# 方式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

# 生產環(huán)境推薦完整保存現場
$ 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

# 優(yōu)雅關閉（Spring Boot應用）
$ kill -15 12345 

# 強制關閉（當優(yōu)雅關閉失效時）
$ kill -9 12345

# 容器化環(huán)境重啟
$ 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());
    }
}

// 業(yè)務代碼應用
public void processOrder(Order order, User user) {
    List<Object> orderedLocks = LockSequencer.sortLocks(orderLock, userLock);
    
    synchronized(orderedLocks.get(0)) {
        synchronized(orderedLocks.get(1)) {
            // 業(yè)務操作
            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;

            // 執(zhí)行核心業(yè)務
            return executeBusiness(order, user);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            // 按獲取的逆序釋放鎖
            if (userLocked) userLock.unlock();
            if (orderLocked) orderLock.unlock();
        }
    }
    
    // 業(yè)務失敗補償機制
    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) {
                // 發(fā)送報警通知
                AlertManager.sendCriticalAlert("DEADLOCK_DETECTED", 
                    "Deadlocked threads: " + Arrays.toString(deadlockedThreads));
                
                // 自動保存診斷信息
                ThreadDumpUtil.saveDiagnosticData();
            }
        }, 1, 5, TimeUnit.MINUTES); // 每5分鐘檢測
        return scheduler;
    }
}

# 啟動實時死鎖監(jiān)控
$ thread -b -i 10

# 監(jiān)控鎖競爭熱點
$ monitor -c 5 java.util.concurrent.locks.ReentrantLock lock

// 使用ChaosBlade注入延遲
@ChaosExperiment
public void simulateDeadlockScenario() {
    // 在鎖獲取時注入延遲
    ChaosBlade.setDelay("java.util.concurrent.locks.ReentrantLock", "lock", 1000);
    
    // 執(zhí)行并發(fā)測試
    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("系統(tǒng)繁忙，請重試");
        }
    }
    
    try {
        // 業(yè)務處理
    } finally {
        // 逆序釋放
        Collections.reverse(locks).forEach(Lock::unlock);
    }
}