死锁 ⭐⭐

public class DeadlockDemo {
 
    // 定义两把锁对象
    private static final Object lockA = new Object(); // 锁 A
    private static final Object lockB = new Object(); // 锁 B
 
    public static void main(String[] args) {
 
        // 线程 A：先拿 lockA，再拿 lockB
        Thread threadA = new Thread(() -> {
            synchronized (lockA) {                     // 第 1 步：获取 lockA ✅ 成功
                System.out.println("线程A: 已持有 lockA, 尝试获取 lockB...");
                try {
                    Thread.sleep(100);                 // 短暂休眠，确保线程 B 有时间拿到 lockB
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (lockB) {                 // 第 2 步：请求 lockB ❌ 阻塞！因为线程 B 持有它
                    System.out.println("线程A: 同时持有 lockA 和 lockB");
                }
            }
        }, "Thread-A");
 
        // 线程 B：先拿 lockB，再拿 lockA（注意：顺序与线程 A 相反！）
        Thread threadB = new Thread(() -> {
            synchronized (lockB) {                     // 第 1 步：获取 lockB ✅ 成功
                System.out.println("线程B: 已持有 lockB, 尝试获取 lockA...");
                try {
                    Thread.sleep(100);                 // 短暂休眠，确保线程 A 有时间拿到 lockA
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (lockA) {                 // 第 2 步：请求 lockA ❌ 阻塞！因为线程 A 持有它
                    System.out.println("线程B: 同时持有 lockB 和 lockA");
                }
            }
        }, "Thread-B");
 
        threadA.start(); // 启动线程 A
        threadB.start(); // 启动线程 B
 
        // 程序将永远卡在这里——两个线程都无法结束
    }
}

线程A: 已持有 lockA, 尝试获取 lockB...
线程B: 已持有 lockB, 尝试获取 lockA...
// 💀 程序卡死，不会有更多输出

时间轴 ──────────────────────────────────────────►
 
Thread-A:  ┃ 获取 lockA ✅ ┃ sleep(100ms) ┃ 请求 lockB ❌ BLOCKED ┃ ...永远等待...
           ┃               ┃              ┃                       ┃
Thread-B:  ┃ 获取 lockB ✅ ┃ sleep(100ms) ┃ 请求 lockA ❌ BLOCKED ┃ ...永远等待...

// 1️⃣ synchronized 块导致的死锁（最经典）
synchronized (lockA) {
    synchronized (lockB) { /* ... */ }       // 经典嵌套锁
}
 
// 2️⃣ ReentrantLock 导致的死锁
lockA.lock();
try {
    lockB.lock();                            // 如果另一线程以相反顺序获取，同样死锁
    try { /* ... */ } finally { lockB.unlock(); }
} finally { lockA.unlock(); }
 
// 3️⃣ 数据库行锁死锁
// 事务 A: UPDATE accounts SET balance=100 WHERE id=1;  (锁住 id=1)
//         UPDATE accounts SET balance=200 WHERE id=2;  (等待 id=2)
// 事务 B: UPDATE accounts SET balance=300 WHERE id=2;  (锁住 id=2)
//         UPDATE accounts SET balance=400 WHERE id=1;  (等待 id=1)
 
// 4️⃣ 线程池死锁（隐蔽！）
// 线程池所有线程都在等待池中其他任务的结果（任务提交到同一个池子里并 get()）
ExecutorService pool = Executors.newFixedThreadPool(2);
Future<String> futureA = pool.submit(() -> {
    Future<String> futureB = pool.submit(() -> "内部任务"); // 提交到同一个池子
    return futureB.get(); // ❌ 如果池子线程用完了，futureB 永远不会被调度
});

资源分配图示例（死锁状态）:
 
    Thread-A ───请求───► LockB
       ▲                    │
       │                    │分配
       │分配                ▼
    LockA ◄───请求─── Thread-B
 
    环路: Thread-A → LockB → Thread-B → LockA → Thread-A
    ✅ 存在环路 → 💀 死锁！

// 互斥的典型表现：synchronized 确保同一时刻只有一个线程能进入临界区
public class MutualExclusionDemo {
 
    // lockA 是一个互斥资源，同一时刻只有一个线程能持有它的 monitor
    private static final Object lockA = new Object();
 
    public static void main(String[] args) {
 
        // 线程 1 获取了 lockA，线程 2 必须等待
        Runnable task = () -> {
            synchronized (lockA) { // <-- 互斥：只有一个线程能进入
                System.out.println(Thread.currentThread().getName() + " 持有 lockA");
                try {
                    Thread.sleep(2000); // 模拟持有锁期间的工作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            } // <-- 离开 synchronized 块后自动释放锁
        };
 
        // 启动两个线程竞争同一把锁
        new Thread(task, "Thread-1").start(); // Thread-1 先拿到锁
        new Thread(task, "Thread-2").start(); // Thread-2 被阻塞，等 Thread-1 释放
    }
}

/**
 * 演示"持有并等待"条件。
 * Thread-1 持有 lockA，等待 lockB。
 * Thread-2 持有 lockB，等待 lockA。
 * 这种交叉持有 + 等待的模式就是"Hold and Wait"。
 */
public class HoldAndWaitDemo {
 
    private static final Object lockA = new Object(); // 资源 A
    private static final Object lockB = new Object(); // 资源 B
 
    public static void main(String[] args) {
 
        // 线程 1：先拿 A，再要 B
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {                    // ① 持有 lockA
                System.out.println("Thread-1: 持有 lockA，准备获取 lockB...");
                sleep(100);                           // 给线程 2 时间去获取 lockB
                synchronized (lockB) {                // ② 等待 lockB（Hold and Wait!）
                    System.out.println("Thread-1: 同时持有 lockA 和 lockB");
                }
            }
        }, "Thread-1");
 
        // 线程 2：先拿 B，再要 A
        Thread t2 = new Thread(() -> {
            synchronized (lockB) {                    // ① 持有 lockB
                System.out.println("Thread-2: 持有 lockB，准备获取 lockA...");
                sleep(100);                           // 给线程 1 时间去获取 lockA
                synchronized (lockA) {                // ② 等待 lockA（Hold and Wait!）
                    System.out.println("Thread-2: 同时持有 lockB 和 lockA");
                }
            }
        }, "Thread-2");
 
        t1.start();
        t2.start();
    }
 
    private static void sleep(long millis) {
        try { Thread.sleep(millis); } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

/**
 * 演示"不可剥夺"特性。
 * 一旦线程获取了 synchronized 锁，外部无法强制释放。
 * 即使调用 t.interrupt()，也无法让线程释放 synchronized 锁。
 */
public class NoPreemptionDemo {
 
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
 
        // 线程 1：获取锁后长时间持有
        Thread t1 = new Thread(() -> {
            synchronized (lock) {                     // 获取锁
                System.out.println("Thread-1: 持有锁，开始长时间工作...");
                try {
                    Thread.sleep(10_000);             // 持有锁 10 秒
                } catch (InterruptedException e) {
                    // 即使被中断，线程仍然持有锁！
                    // interrupt 只是设置了中断标志 + 让 sleep 提前返回
                    // 但 synchronized 锁不会因此释放
                    System.out.println("Thread-1: 被中断了，但我仍持有锁！");
                }
                System.out.println("Thread-1: 工作完成，即将释放锁");
            } // <-- 只有执行到这里，锁才会释放
        }, "Thread-1");
 
        // 线程 2：等待获取同一把锁
        Thread t2 = new Thread(() -> {
            System.out.println("Thread-2: 尝试获取锁...");
            synchronized (lock) {                     // 阻塞等待 Thread-1 释放
                System.out.println("Thread-2: 终于获取到锁了！");
            }
        }, "Thread-2");
 
        t1.start();
        Thread.sleep(100);    // 确保 Thread-1 先获取到锁
        t2.start();
        Thread.sleep(100);    // 确保 Thread-2 已经开始等待
 
        // 尝试中断 Thread-1 —— 这不会让它释放 synchronized 锁
        System.out.println("主线程: 尝试中断 Thread-1...");
        t1.interrupt();       // 中断只影响 sleep/wait/join，不影响 synchronized 持锁
 
        t1.join();
        t2.join();
    }
}

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
 
/**
 * ReentrantLock 提供了"可剥夺"（主动放弃）的能力，
 * 这是 synchronized 所不具备的。
 */
public class PreemptionComparisonDemo {
 
    private static final ReentrantLock lockA = new ReentrantLock();
    private static final ReentrantLock lockB = new ReentrantLock();
 
    public static void main(String[] args) {
 
        Thread t1 = new Thread(() -> {
            try {
                // tryLock：尝试获取 lockA，最多等 2 秒
                if (lockA.tryLock(2, TimeUnit.SECONDS)) {     // 尝试获取 lockA
                    try {
                        System.out.println("Thread-1: 持有 lockA");
                        Thread.sleep(100);
 
                        // tryLock：尝试获取 lockB，最多等 2 秒
                        if (lockB.tryLock(2, TimeUnit.SECONDS)) { // 尝试获取 lockB
                            try {
                                System.out.println("Thread-1: 持有 lockA 和 lockB，执行业务");
                            } finally {
                                lockB.unlock();                // 释放 lockB
                            }
                        } else {
                            // 获取 lockB 超时 —— 主动放弃！
                            System.out.println("Thread-1: 获取 lockB 超时，主动放弃");
                        }
                    } finally {
                        lockA.unlock();                        // 释放 lockA
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Thread-1");
 
        t1.start();
    }
}

// 最小的循环等待：两个线程，两把锁
// T1: lockA -> 等待 lockB
// T2: lockB -> 等待 lockA
// 等待链: T1 → T2 → T1 （环！）

/**
 * 三线程循环等待死锁演示。
 * Thread-1: lockA -> 等待 lockB
 * Thread-2: lockB -> 等待 lockC
 * Thread-3: lockC -> 等待 lockA
 * 形成 T1 → T2 → T3 → T1 的等待环。
 */
public class CircularWaitDemo {
 
    private static final Object lockA = new Object(); // 资源 A
    private static final Object lockB = new Object(); // 资源 B
    private static final Object lockC = new Object(); // 资源 C
 
    public static void main(String[] args) {
 
        // Thread-1: 持有 A，等待 B
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {                    // 获取 lockA
                System.out.println("Thread-1: 持有 lockA");
                sleep(100);                           // 等待其他线程获取各自的锁
                synchronized (lockB) {                // 等待 lockB（被 Thread-2 持有）
                    System.out.println("Thread-1: 持有 lockA + lockB");
                }
            }
        }, "Thread-1");
 
        // Thread-2: 持有 B，等待 C
        Thread t2 = new Thread(() -> {
            synchronized (lockB) {                    // 获取 lockB
                System.out.println("Thread-2: 持有 lockB");
                sleep(100);                           // 等待其他线程获取各自的锁
                synchronized (lockC) {                // 等待 lockC（被 Thread-3 持有）
                    System.out.println("Thread-2: 持有 lockB + lockC");
                }
            }
        }, "Thread-2");
 
        // Thread-3: 持有 C，等待 A
        Thread t3 = new Thread(() -> {
            synchronized (lockC) {                    // 获取 lockC
                System.out.println("Thread-3: 持有 lockC");
                sleep(100);                           // 等待其他线程获取各自的锁
                synchronized (lockA) {                // 等待 lockA（被 Thread-1 持有）
                    System.out.println("Thread-3: 持有 lockC + lockA");
                }
            }
        }, "Thread-3");
 
        t1.start();
        t2.start();
        t3.start();
    }
 
    private static void sleep(long millis) {
        try { Thread.sleep(millis); } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class ClassicDeadlockDemo {
 
    // 定义两把锁对象（任意 Object 即可，仅用于 synchronized）
    private static final Object lockA = new Object(); // 锁 A
    private static final Object lockB = new Object(); // 锁 B
 
    public static void main(String[] args) {
 
        // ========== 线程 1：先拿 lockA，再请求 lockB ==========
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {                         // 第 1 步：获取 lockA ✅
                System.out.println(Thread.currentThread().getName()
                        + " 已持有 lockA，尝试获取 lockB...");
 
                sleep(100);                                // 故意休眠，确保 t2 有时间拿到 lockB
 
                synchronized (lockB) {                     // 第 2 步：请求 lockB —— 被 t2 持有，阻塞 🔒
                    System.out.println(Thread.currentThread().getName()
                            + " 成功获取 lockB");          // ❌ 永远不会执行到这里
                }
            }
        }, "Thread-1");
 
        // ========== 线程 2：先拿 lockB，再请求 lockA ==========
        Thread t2 = new Thread(() -> {
            synchronized (lockB) {                         // 第 1 步：获取 lockB ✅
                System.out.println(Thread.currentThread().getName()
                        + " 已持有 lockB，尝试获取 lockA...");
 
                sleep(100);                                // 故意休眠，确保 t1 有时间拿到 lockA
 
                synchronized (lockA) {                     // 第 2 步：请求 lockA —— 被 t1 持有，阻塞 🔒
                    System.out.println(Thread.currentThread().getName()
                            + " 成功获取 lockA");          // ❌ 永远不会执行到这里
                }
            }
        }, "Thread-2");
 
        t1.start();                                        // 启动线程 1
        t2.start();                                        // 启动线程 2
 
        // 主线程等待 3 秒后检测是否存活（死锁时两个线程永远不会结束）
        sleep(3000);
        System.out.println("Thread-1 存活: " + t1.isAlive()); // true → 死锁
        System.out.println("Thread-2 存活: " + t2.isAlive()); // true → 死锁
        System.out.println("💀 检测到死锁！程序无法正常退出。");
    }
 
    // 辅助方法：安全休眠，忽略中断异常
    private static void sleep(long millis) {
        try { Thread.sleep(millis); } catch (InterruptedException ignored) {}
    }
}

Thread-1 已持有 lockA，尝试获取 lockB...
Thread-2 已持有 lockB，尝试获取 lockA...
Thread-1 存活: true
Thread-2 存活: true
💀 检测到死锁！程序无法正常退出。

转账 1：Alice → Bob    →  先锁 Alice，再锁 Bob
转账 2：Bob   → Alice  →  先锁 Bob，  再锁 Alice
                           ↑ 循环等待！

public class TransferDeadlockDemo {
 
    // ==================== 账户类 ====================
    static class Account {
        private final String name;    // 账户名称
        private int balance;          // 账户余额（单位：分）
 
        public Account(String name, int balance) {
            this.name = name;         // 初始化账户名
            this.balance = balance;   // 初始化余额
        }
 
        public String getName() { return name; }          // 获取账户名
        public int getBalance() { return balance; }        // 获取余额
        public void debit(int amount) { balance -= amount; }   // 扣款
        public void credit(int amount) { balance += amount; }  // 入账
    }
 
    // ==================== 转账方法（有死锁风险！） ====================
    /**
     * 从 from 账户向 to 账户转账 amount 元
     * 需要同时锁住两个账户以保证原子性
     * ❌ 此实现存在死锁风险！
     */
    static void transferUnsafe(Account from, Account to, int amount) {
        synchronized (from) {                              // 第 1 步：锁定转出账户
            System.out.println(Thread.currentThread().getName()
                    + " 锁定 " + from.getName()
                    + "，准备锁定 " + to.getName() + "...");
 
            sleep(50);                                     // 模拟业务耗时（风控校验等）
 
            synchronized (to) {                            // 第 2 步：锁定转入账户
                if (from.getBalance() >= amount) {         // 校验余额是否充足
                    from.debit(amount);                    // 从转出方扣款
                    to.credit(amount);                     // 向转入方入账
                    System.out.println(Thread.currentThread().getName()
                            + " 转账成功: " + from.getName()
                            + " → " + to.getName()
                            + " ¥" + amount);
                } else {
                    System.out.println("余额不足，转账失败"); // 余额不足时拒绝转账
                }
            }
        }
    }
 
    // ==================== 主方法 ====================
    public static void main(String[] args) {
 
        Account alice = new Account("Alice", 10000);       // Alice 初始余额 10000
        Account bob = new Account("Bob", 10000);           // Bob 初始余额 10000
 
        // 转账 1：Alice → Bob，金额 100（先锁 Alice，再锁 Bob）
        Thread t1 = new Thread(
                () -> transferUnsafe(alice, bob, 100),
                "转账线程-1"
        );
 
        // 转账 2：Bob → Alice，金额 200（先锁 Bob，再锁 Alice）
        Thread t2 = new Thread(
                () -> transferUnsafe(bob, alice, 200),
                "转账线程-2"
        );
 
        t1.start();                                        // 启动转账线程 1
        t2.start();                                        // 启动转账线程 2
 
        // 等待 5 秒后检查线程状态
        sleep(5000);
        if (t1.isAlive() && t2.isAlive()) {                // 两个线程都还活着 → 死锁
            System.out.println("\n💀 转账系统死锁！");
            System.out.println("Alice 余额: " + alice.getBalance()); // 余额没有变化
            System.out.println("Bob   余额: " + bob.getBalance());   // 余额没有变化
        }
    }
 
    private static void sleep(long millis) {
        try { Thread.sleep(millis); } catch (InterruptedException ignored) {}
    }
}

转账线程-1 锁定 Alice，准备锁定 Bob...
转账线程-2 锁定 Bob，准备锁定 Alice...
 
💀 转账系统死锁！
Alice 余额: 10000
Bob   余额: 10000

import java.util.HashSet;
import java.util.Set;
 
public class HiddenDeadlockDemo {
 
    // ==================== 出租车类 ====================
    static class Taxi {
        private final String id;               // 出租车编号
        private String location;               // 当前位置
        private String destination;            // 目的地
        private final Dispatcher dispatcher;   // 关联的调度器
 
        public Taxi(String id, Dispatcher dispatcher) {
            this.id = id;                      // 初始化编号
            this.dispatcher = dispatcher;      // 绑定调度器
        }
 
        // 获取当前位置（synchronized 保护读取）
        public synchronized String getLocation() {
            return location;                   // 返回当前位置
        }
 
        // 设置新位置 —— 注意：内部会回调 dispatcher 的同步方法！
        public synchronized void setLocation(String newLocation) {
            this.location = newLocation;       // 更新位置
            if (newLocation.equals(destination)) {  // 如果到达目的地
                // ⚠️ 关键：持有 this(Taxi) 锁的同时，调用 dispatcher 的 synchronized 方法
                dispatcher.notifyAvailable(this);   // 通知调度器"我空闲了"
            }
        }
 
        public synchronized void setDestination(String dest) {
            this.destination = dest;           // 设置目的地
        }
 
        public String getId() { return id; }  // 获取编号
    }
 
    // ==================== 调度器类 ====================
    static class Dispatcher {
        private final Set<Taxi> availableTaxis = new HashSet<>();  // 空闲出租车集合
        private final Set<Taxi> allTaxis = new HashSet<>();        // 全部出租车集合
 
        // 注册出租车
        public synchronized void addTaxi(Taxi taxi) {
            allTaxis.add(taxi);                // 加入全部列表
            availableTaxis.add(taxi);          // 初始为空闲状态
        }
 
        // 出租车到达目的地后通知空闲
        public synchronized void notifyAvailable(Taxi taxi) {
            availableTaxis.add(taxi);          // 将出租车标记为空闲
            System.out.println("调度器: " + taxi.getId() + " 已空闲");
        }
 
        // 打印所有出租车位置 —— 注意：内部会调用 taxi 的 synchronized 方法！
        public synchronized void printAllLocations() {
            for (Taxi taxi : allTaxis) {       // 遍历所有出租车
                // ⚠️ 关键：持有 this(Dispatcher) 锁的同时，调用 taxi 的 synchronized 方法
                System.out.println(taxi.getId() + " @ " + taxi.getLocation());
            }
        }
    }
 
    // ==================== 主方法：触发死锁 ====================
    public static void main(String[] args) {
 
        Dispatcher dispatcher = new Dispatcher();          // 创建调度器
        Taxi taxi = new Taxi("沪A-12345", dispatcher);    // 创建出租车
        taxi.setDestination("浦东机场");                   // 设置目的地
        dispatcher.addTaxi(taxi);                          // 注册到调度器
 
        // 线程 1：出租车到达目的地，更新位置
        // 加锁顺序：Taxi 锁 → Dispatcher 锁
        Thread gpsUpdater = new Thread(() -> {
            while (true) {
                taxi.setLocation("浦东机场");              // 持有 Taxi 锁 → 调用 dispatcher.notifyAvailable()
                sleep(1);                                  // 短暂休眠模拟 GPS 更新频率
            }
        }, "GPS-Updater");
 
        // 线程 2：调度器打印所有出租车位置
        // 加锁顺序：Dispatcher 锁 → Taxi 锁
        Thread monitor = new Thread(() -> {
            while (true) {
                dispatcher.printAllLocations();            // 持有 Dispatcher 锁 → 调用 taxi.getLocation()
                sleep(1);                                  // 短暂休眠
            }
        }, "Monitor");
 
        gpsUpdater.start();                                // 启动 GPS 更新线程
        monitor.start();                                   // 启动监控线程
 
        // 由于两线程高频交替执行，死锁很快就会发生
        sleep(5000);
        System.out.println("GPS-Updater alive: " + gpsUpdater.isAlive());
        System.out.println("Monitor alive: " + monitor.isAlive());
    }
 
    private static void sleep(long millis) {
        try { Thread.sleep(millis); } catch (InterruptedException ignored) {}
    }
}

Object lockX = new Object();
Object lockY = new Object();

# 方式一：jps（JDK 自带，推荐）
# jps 会列出当前用户下所有 Java 进程及其主类名
jps -l
 
# 输出示例：
# 12345 com.example.DeadlockDemo    ← 这就是我们要找的进程
# 12400 jdk.jcmd/sun.tools.jps.Jps  ← jps 自身
 
# 方式二：Linux 通用命令
ps -ef | grep java
 
# 方式三：更精确的筛选
ps aux | grep DeadlockDemo

# 基本用法：jstack <PID>
jstack 12345
 
# 如果遇到权限问题（如目标进程由其他用户启动），加 sudo
sudo jstack 12345
 
# 将输出重定向到文件，方便后续分析
jstack 12345 > thread_dump_20240101.txt
 
# -l 参数：打印额外的锁信息（ownable synchronizers）
# 在排查死锁时强烈推荐加上 -l
jstack -l 12345 > thread_dump_detail.txt

public class DeadlockDemo {
 
    // 定义两把锁对象
    private static final Object LOCK_A = new Object(); // 锁 A
    private static final Object LOCK_B = new Object(); // 锁 B
 
    public static void main(String[] args) {
 
        // 线程1：先拿 A，再拿 B
        Thread t1 = new Thread(() -> {
            synchronized (LOCK_A) {                              // 第一步：获取锁 A
                System.out.println("线程1: 已持有 LOCK_A");
                try { Thread.sleep(100); } catch (Exception e) {} // 休眠，确保线程2有时间拿到锁 B
                System.out.println("线程1: 尝试获取 LOCK_B...");
                synchronized (LOCK_B) {                          // 第二步：尝试获取锁 B（会被阻塞）
                    System.out.println("线程1: 已持有 LOCK_A 和 LOCK_B");
                }
            }
        }, "Worker-Thread-1"); // 给线程取一个有意义的名字，方便在 jstack 中识别
 
        // 线程2：先拿 B，再拿 A（与线程1顺序相反，形成循环等待）
        Thread t2 = new Thread(() -> {
            synchronized (LOCK_B) {                              // 第一步：获取锁 B
                System.out.println("线程2: 已持有 LOCK_B");
                try { Thread.sleep(100); } catch (Exception e) {} // 休眠，确保线程1有时间拿到锁 A
                System.out.println("线程2: 尝试获取 LOCK_A...");
                synchronized (LOCK_A) {                          // 第二步：尝试获取锁 A（会被阻塞）
                    System.out.println("线程2: 已持有 LOCK_B 和 LOCK_A");
                }
            }
        }, "Worker-Thread-2");
 
        t1.start(); // 启动线程1
        t2.start(); // 启动线程2
    }
}

# 先找到 PID
jps -l
# 假设输出: 12345 DeadlockDemo
 
# 抓取线程快照（带锁详情）
jstack -l 12345

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
 
public class DeadlockDetector {
 
    // 获取 JVM 线程管理 MXBean
    private static final ThreadMXBean THREAD_MX_BEAN = ManagementFactory.getThreadMXBean();
 
    public static void main(String[] args) {
 
        // 启动一个守护线程, 每隔 5 秒检测一次死锁
        Thread detector = new Thread(() -> {
            while (true) {                                        // 持续轮询
                // findDeadlockedThreads() 返回死锁线程的 ID 数组
                // 如果没有死锁, 返回 null
                long[] deadlockedIds = THREAD_MX_BEAN.findDeadlockedThreads();
 
                if (deadlockedIds != null) {                      // 检测到死锁!
                    System.err.println("⚠️ 检测到死锁! 涉及线程:");
 
                    // 根据线程 ID 获取详细的 ThreadInfo（包含堆栈和锁信息）
                    ThreadInfo[] threadInfos = THREAD_MX_BEAN.getThreadInfo(deadlockedIds, true, true);
 
                    for (ThreadInfo info : threadInfos) {         // 遍历每个死锁线程
                        System.err.println("  线程: " + info.getThreadName());  // 线程名
                        System.err.println("  状态: " + info.getThreadState()); // 线程状态
                        System.err.println("  等待锁: " + info.getLockName());  // 正在等待的锁
                        System.err.println("  锁持有者: " + info.getLockOwnerName()); // 锁被谁持有
                        System.err.println("  堆栈:");
 
                        // 打印该线程的完整调用栈
                        for (StackTraceElement ste : info.getStackTrace()) {
                            System.err.println("    at " + ste);  // 逐帧打印
                        }
                        System.err.println();                     // 空行分隔
                    }
 
                    // 实际生产中: 发送告警邮件/钉钉通知, 或触发线程 dump 保存
                    // AlertService.sendDeadlockAlert(threadInfos);
                }
 
                try {
                    Thread.sleep(5000);                           // 每 5 秒检测一次
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();            // 恢复中断状态
                    break;                                        // 退出循环
                }
            }
        }, "Deadlock-Detector");
 
        detector.setDaemon(true); // 设为守护线程, 主线程退出时自动结束
        detector.start();         // 启动检测
 
        // ... 在这里启动你的业务线程 ...
    }
}

public class LockOrderingDemo {
 
    // 账户类
    static class Account {
        private final int id;          // 账户唯一标识
        private double balance;        // 账户余额
 
        public Account(int id, double balance) {
            this.id = id;              // 构造时指定 ID
            this.balance = balance;    // 构造时指定初始余额
        }
 
        public int getId() { return id; }             // 获取 ID
        public double getBalance() { return balance; } // 获取余额
 
        // 存款（非线程安全，依赖外部加锁）
        public void credit(double amount) {
            this.balance += amount;    // 增加余额
        }
 
        // 取款（非线程安全，依赖外部加锁）
        public void debit(double amount) {
            this.balance -= amount;    // 减少余额
        }
    }
 
    /**
     * 安全的转账方法 —— 使用锁排序避免死锁
     * 核心策略：始终先锁 id 小的账户，再锁 id 大的账户
     */
    public static void transferMoney(Account from, Account to, double amount) {
        // 第一步：确定加锁顺序（按 id 从小到大）
        Account firstLock;             // 先锁定的账户
        Account secondLock;            // 后锁定的账户
 
        if (from.getId() < to.getId()) {
            firstLock = from;          // from 的 id 更小，先锁 from
            secondLock = to;           // 后锁 to
        } else if (from.getId() > to.getId()) {
            firstLock = to;            // to 的 id 更小，先锁 to
            secondLock = from;         // 后锁 from
        } else {
            // id 相同：自己转给自己，不需要转账
            throw new IllegalArgumentException("Cannot transfer to the same account!");
        }
 
        // 第二步：按固定顺序加锁
        synchronized (firstLock) {                     // 先获取 id 小的锁
            synchronized (secondLock) {                // 再获取 id 大的锁
                if (from.getBalance() < amount) {      // 检查余额是否充足
                    throw new RuntimeException("Insufficient balance!");
                }
                from.debit(amount);                    // 从转出账户扣款
                to.credit(amount);                     // 向转入账户加款
                System.out.printf("转账成功: Account-%d → Account-%d, 金额: %.2f%n",
                        from.getId(), to.getId(), amount);
            }
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        Account accountA = new Account(1, 10000);     // 账户A，id=1
        Account accountB = new Account(2, 10000);     // 账户B，id=2
 
        // 线程1：A 转给 B —— 内部会先锁 id=1(A)，再锁 id=2(B)
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {           // 循环转账 1000 次
                transferMoney(accountA, accountB, 1);  // A → B
            }
        }, "Thread-A2B");
 
        // 线程2：B 转给 A —— 内部也会先锁 id=1(A)，再锁 id=2(B)
        // 虽然参数是 (B, A)，但方法内部会重新排序！
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {           // 循环转账 1000 次
                transferMoney(accountB, accountA, 1);  // B → A（内部仍然先锁A再锁B）
            }
        }, "Thread-B2A");
 
        t1.start();                                    // 启动线程1
        t2.start();                                    // 启动线程2
        t1.join();                                     // 等待线程1完成
        t2.join();                                     // 等待线程2完成
 
        // 最终两个账户余额之和应该不变（守恒）
        System.out.println("Account-A 余额: " + accountA.getBalance());
        System.out.println("Account-B 余额: " + accountB.getBalance());
        System.out.println("总额: " + (accountA.getBalance() + accountB.getBalance()));
    }
}

// 全局裁决锁：仅在 identityHashCode 冲突时使用
private static final Object TIE_LOCK = new Object();
 
public static void safeTransfer(Account from, Account to, double amount) {
    int fromHash = System.identityHashCode(from);     // 获取 from 的 identity hash
    int toHash = System.identityHashCode(to);         // 获取 to 的 identity hash
 
    if (fromHash < toHash) {
        synchronized (from) {                          // hash 小的先锁
            synchronized (to) {                        // hash 大的后锁
                doTransfer(from, to, amount);          // 执行转账
            }
        }
    } else if (fromHash > toHash) {
        synchronized (to) {                            // hash 小的先锁
            synchronized (from) {                      // hash 大的后锁
                doTransfer(from, to, amount);          // 执行转账
            }
        }
    } else {
        // Hash 冲突！使用全局裁决锁保证此场景下串行化
        synchronized (TIE_LOCK) {                      // 先获取全局锁，消除冲突
            synchronized (from) {                      // 再按任意顺序锁
                synchronized (to) {                    // 因为全局锁已串行化，不会死锁
                    doTransfer(from, to, amount);      // 执行转账
                }
            }
        }
    }
}

public class AtomicLockAcquisitionDemo {
 
    static class Account {
        private final String name;     // 账户名称
        private double balance;        // 账户余额
 
        public Account(String name, double balance) {
            this.name = name;          // 初始化名称
            this.balance = balance;    // 初始化余额
        }
 
        // getter / setter 省略...
        public String getName() { return name; }
        public double getBalance() { return balance; }
        public void credit(double amt) { balance += amt; }
        public void debit(double amt) { balance -= amt; }
    }
 
    /**
     * 资源分配器：一次性获取多个资源
     * 核心思想：要么全部获取，要么全不获取
     */
    static class ResourceAllocator {
        // 记录当前已被某线程"占用"的账户集合
        private final Set<Account> allocatedResources = new HashSet<>();
 
        /**
         * 尝试一次性申请多个账户的"使用权"
         * @return true 表示申请成功，false 表示资源被占用需要重试
         */
        public synchronized boolean tryAllocate(Account... accounts) {
            // 检查所有请求的资源是否都空闲
            for (Account acc : accounts) {
                if (allocatedResources.contains(acc)) {
                    return false;                      // 有任何一个被占用，整体失败
                }
            }
            // 所有资源都空闲，一次性全部分配
            for (Account acc : accounts) {
                allocatedResources.add(acc);           // 标记为已分配
            }
            return true;                               // 分配成功
        }
 
        /**
         * 释放之前申请的资源
         */
        public synchronized void free(Account... accounts) {
            for (Account acc : accounts) {
                allocatedResources.remove(acc);        // 从已分配集合中移除
            }
            this.notifyAll();                          // 唤醒所有等待分配的线程
        }
 
        /**
         * 阻塞式获取：如果无法一次性获取，就等待直到成功
         */
        public synchronized void allocate(Account... accounts) throws InterruptedException {
            while (!tryAllocate(accounts)) {           // 自旋 + 等待
                this.wait();                           // 获取失败，释放 allocator 锁并等待
            }
        }
    }
 
    // 全局唯一的资源分配器
    private static final ResourceAllocator allocator = new ResourceAllocator();
 
    /**
     * 使用分配器实现安全转账
     */
    public static void transferMoney(Account from, Account to, double amount)
            throws InterruptedException {
        // 第一步：一次性申请两个账户的使用权（阻塞直到成功）
        allocator.allocate(from, to);
 
        try {
            // 第二步：此时已独占两个账户，安全地执行转账
            // 注意：这里不再需要 synchronized，因为分配器已经保证了排他性
            if (from.getBalance() >= amount) {         // 检查余额
                from.debit(amount);                    // 扣款
                to.credit(amount);                     // 加款
                System.out.printf("[%s] %s → %s, 金额: %.2f%n",
                        Thread.currentThread().getName(),
                        from.getName(), to.getName(), amount);
            }
        } finally {
            // 第三步：无论成功与否，都必须释放资源
            allocator.free(from, to);                  // 归还使用权
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account("Alice", 10000);      // Alice 初始余额 10000
        Account b = new Account("Bob", 10000);        // Bob 初始余额 10000
 
        Thread t1 = new Thread(() -> {
            try {
                for (int i = 0; i < 1000; i++)        // 循环转账 1000 次
                    transferMoney(a, b, 1);            // Alice → Bob
            } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        }, "T1");
 
        Thread t2 = new Thread(() -> {
            try {
                for (int i = 0; i < 1000; i++)        // 循环转账 1000 次
                    transferMoney(b, a, 1);            // Bob → Alice
            } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        }, "T2");
 
        t1.start();                                    // 启动线程1
        t2.start();                                    // 启动线程2
        t1.join();                                     // 等待线程1完成
        t2.join();                                     // 等待线程2完成
 
        System.out.println("Alice: " + a.getBalance());
        System.out.println("Bob:   " + b.getBalance());
        System.out.println("Total: " + (a.getBalance() + b.getBalance()));
    }
}

// 尝试在指定时间内获取锁
// 如果超时仍未获取到，返回 false 而不是永久阻塞
boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
 
public class TryLockDemo {
 
    static class Account {
        private final String name;                     // 账户名称
        private double balance;                        // 账户余额
        private final ReentrantLock lock               // 每个账户一把锁
                = new ReentrantLock();
 
        public Account(String name, double balance) {
            this.name = name;                          // 初始化名称
            this.balance = balance;                    // 初始化余额
        }
 
        public String getName() { return name; }
        public double getBalance() { return balance; }
        public ReentrantLock getLock() { return lock; }
        public void credit(double amt) { balance += amt; }
        public void debit(double amt) { balance -= amt; }
    }
 
    /**
     * 使用 tryLock + 超时机制实现安全转账
     * 如果无法在超时时间内获取两把锁，则主动回退重试
     */
    public static boolean transferMoney(Account from, Account to,
                                        double amount, long timeout, TimeUnit unit)
            throws InterruptedException {
 
        // 计算超时的绝对截止时间
        long stopTime = System.nanoTime() + unit.toNanos(timeout);
 
        while (true) {
            // 第一步：尝试获取 from 账户的锁
            if (from.getLock().tryLock()) {             // 非阻塞尝试获取第一把锁
                try {
                    // 第二步：尝试获取 to 账户的锁
                    if (to.getLock().tryLock()) {       // 非阻塞尝试获取第二把锁
                        try {
                            // 两把锁都获取成功，执行转账
                            if (from.getBalance() < amount) {
                                System.out.println("余额不足!");
                                return false;          // 余额不足，转账失败
                            }
                            from.debit(amount);        // 扣款
                            to.credit(amount);         // 加款
                            return true;               // 转账成功
                        } finally {
                            to.getLock().unlock();      // 释放 to 的锁
                        }
                    }
                    // 如果 to 的锁获取失败，走到这里
                    // from 的锁会在下面的 finally 中释放
                } finally {
                    from.getLock().unlock();            // 释放 from 的锁（无论 to 是否成功）
                }
            }
 
            // 走到这里说明没有同时获取到两把锁
            // 检查是否超时
            if (System.nanoTime() >= stopTime) {
                System.out.println("转账超时，放弃！");
                return false;                          // 超时退出，避免无限重试
            }
 
            // 随机短暂休眠，避免活锁（两个线程同步重试、同步失败）
            Thread.sleep((long)(Math.random() * 10));  // 随机退避 0~10ms
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        Account alice = new Account("Alice", 10000);   // Alice 初始余额
        Account bob = new Account("Bob", 10000);       // Bob 初始余额
 
        // 线程1：Alice → Bob，超时 1 秒
        Thread t1 = new Thread(() -> {
            try {
                for (int i = 0; i < 1000; i++) {
                    transferMoney(alice, bob, 1,
                            1, TimeUnit.SECONDS);      // 每次转账超时 1 秒
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "T-A2B");
 
        // 线程2：Bob → Alice，超时 1 秒
        Thread t2 = new Thread(() -> {
            try {
                for (int i = 0; i < 1000; i++) {
                    transferMoney(bob, alice, 1,
                            1, TimeUnit.SECONDS);      // 每次转账超时 1 秒
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "T-B2A");
 
        t1.start();
        t2.start();
        t1.join();
        t2.join();
 
        System.out.println("Alice: " + alice.getBalance());
        System.out.println("Bob:   " + bob.getBalance());
        System.out.println("Total: " + (alice.getBalance() + bob.getBalance()));
    }
}

ReentrantLock lockA = new ReentrantLock();
ReentrantLock lockB = new ReentrantLock();
 
// 线程1
new Thread(() -> {
    lockA.lock();
    try {
        Thread.sleep(100);
        if (lockB.tryLock(50, TimeUnit.MILLISECONDS)) {
            try {
                System.out.println("T1 完成");
            } finally { lockB.unlock(); }
        } else {
            System.out.println("T1 获取 lockB 超时，放弃");
        }
    } catch (InterruptedException e) { }
    finally { lockA.unlock(); }
}).start();
 
// 线程2
new Thread(() -> {
    lockB.lock();
    try {
        Thread.sleep(100);
        if (lockA.tryLock(50, TimeUnit.MILLISECONDS)) {
            try {
                System.out.println("T2 完成");
            } finally { lockA.unlock(); }
        } else {
            System.out.println("T2 获取 lockA 超时，放弃");
        }
    } catch (InterruptedException e) { }
    finally { lockB.unlock(); }
}).start();

// 场景一：锁的数量固定且已知（如两个账户互转）
// ✅ 推荐：锁排序（Lock Ordering）
// 理由：简单高效，零额外开销，代码可读性好
synchronized (Math.min(a, b) == a ? lockA : lockB) {
    synchronized (Math.max(a, b) == a ? lockA : lockB) {
        // 转账逻辑...
    }
}
 
// 场景二：需要同时持有多个动态数量的锁
// ✅ 推荐：一次性获取（All-or-Nothing）
// 理由：将多锁问题降维为单锁问题，逻辑最清晰
synchronized (globalLock) {
    // 持有全局锁后，安全操作所有资源...
}
 
// 场景三：高并发、不能容忍永久等待（如交易系统）
// ✅ 推荐：tryLock 超时机制
// 理由：可主动退出等待，配合重试策略保证系统活性
if (lock1.tryLock(1, TimeUnit.SECONDS)) {
    try {
        if (lock2.tryLock(1, TimeUnit.SECONDS)) {
            try {
                // 业务逻辑...
            } finally { lock2.unlock(); }
        }
    } finally { lock1.unlock(); }
}

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