出现死锁问题怎么解决？

最新推荐文章于 2024-04-30 00:04:23 发布

知识不加糖

最新推荐文章于 2024-04-30 00:04:23 发布

阅读量1.2k

点赞数

文章标签： java 多线程并发编程

本文链接：https://blog.csdn.net/a979331856/article/details/105506727

版权

什么是死锁

每个线程都在等待对方线程释放锁，然而谁都不主动释放锁，结果就构成死锁。

死锁的影响在不同系统中是不一样的，这取决于系统对死锁的处理能力。

数据库：检测并放弃事务。

JVM ：无法自动处理。

发生死锁的例子

经典死锁

public class DeadLock implements Runnable {

    int flag = 1;

    static Object lock1 = new Object();
    static Object lock2 = new Object();

    public static void main(String[] args) {
        DeadLock deadLock1 = new DeadLock();
        DeadLock deadLock2 = new DeadLock();
        deadLock1.flag = 1;
        deadLock2.flag = 0;
        Thread t1 = new Thread(deadLock1);
        Thread t2 = new Thread(deadLock2);
        t1.start();
        t2.start();
    }

    @Override
    public void run() {
        System.out.println("flag = " + flag);
        if (flag == 1) {
            synchronized (lock1) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("线程1成功拿到两把锁");
                }
            }
        }
        if (flag == 0) {
            synchronized (lock2) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("线程2成功拿到两把锁");
                }
            }
        }
    }
}

由于 lock1 在等 lock2 释放锁，而 lock2 在等 lock1 释放锁，从而构成了死锁。

转账

public class TransferMoney implements Runnable {

    int flag = 1;
    static Account a = new Account(500);
    static Account b = new Account(500);

    public static void main(String[] args) throws InterruptedException {
        TransferMoney r1 = new TransferMoney();
        TransferMoney r2 = new TransferMoney();
        r1.flag = 1;
        r2.flag = 0;
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("a的余额" + a.balance);
        System.out.println("b的余额" + b.balance);
    }

    @Override
    public void run() {
        if (flag == 1) {
            transferMoney(a, b, 200);
        }
        if (flag == 0) {
            transferMoney(b, a, 200);
        }
    }

    public static void transferMoney(Account from, Account to, int amount) {

        synchronized (from) {
            try {
                // 模拟耗时操作
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (to) {
                if (from.balance - amount < 0) {
                    System.out.println("余额不足，转账失败。");
                    return;
                }
                from.balance -= amount;
                to.balance = to.balance + amount;
                System.out.println("成功转账" + amount + "元");
            }
        }
    }

    static class Account {

        public Account(int balance) {
            this.balance = balance;
        }

        int balance;
    }
}

多人随机转账

public class MultiTransferMoney {

    // 人越少，死锁几率越大
    private static final int NUM_ACCOUNTS = 50;
    private static final int NUM_MONEY = 1000;
    private static final int NUM_ITERATIONS = 1000000;
    private static final int NUM_THREADS = 20;

    public static void main(String[] args) {

        Random rnd = new Random();
        TransferMoney.Account[] accounts = new TransferMoney.Account[NUM_ACCOUNTS];
        for (int i = 0; i < accounts.length; i++) {
            accounts[i] = new TransferMoney.Account(NUM_MONEY);
        }
        class TransferThread extends Thread {

            @Override
            public void run() {
                for (int i = 0; i < NUM_ITERATIONS; i++) {
                    int fromAcct = rnd.nextInt(NUM_ACCOUNTS);
                    int toAcct = rnd.nextInt(NUM_ACCOUNTS);
                    int amount = rnd.nextInt(NUM_MONEY);
                    TransferMoney.transferMoney(accounts[fromAcct], accounts[toAcct], amount);
                }
                System.out.println("运行结束");
            }
        }
        for (int i = 0; i < NUM_THREADS; i++) {
            new TransferThread().start();
        }
    }
}

死锁的必要条件

死锁的产生具备以下四个条件：

互斥条件：指线程对己经获取到的资源进行排它性使用，即该资源同时只由一个线程占用。如果此时还有其他线程请求获取该资源，则请求者只能等待，直至占有资源的线程释放该资源。
请求并持有条件：指一个线程己经持有了至少一个资源，但又提出了新的资源请求，而新资源己被其他线程占有，所以当前线程会被阻塞，但阻塞的同时并不释放自己己经获取的资源。
不可剥夺条件：指线程获取到的资源在自己使用完之前不能被其他线程抢占，只有在自己使用完毕后才由自己释放该资源。
环路等待条件：指在发生死锁时，必然存在一个线程→资源的环形链，即线程集合{ T0，T1，T2 ，…，Tn ｝中的 T0 正在等待一个 T1 占用的资源，T1 正在等待 T2 占用的资源，……Tn 正在等待己被 T0 占用的资源。

来看上面的经典死锁示例是如何满足这四个条件的。

首先，lock1 和 lock2 都是互斥资源，当线程 1 调用 synchronized(lock1) 方法获取到 lock1 锁并释放前，线程 2 再调用 synchronized(lock1) 方法尝试获取该资源会被阻塞，只有线程 1 主动释放该锁，线程 2 才能获得，这满足了资源互斥条件 。线程 1 首先通过 synchronized(lock1) 方法获取到 lock1 锁，然后通过 synchronized(lock2) 方法等待获取 lock2 锁，这就构成了请求并持有条件。线程 1 在获取 lock1 锁后，该资源不会被线程 2 掠夺走，只有线程 1 自己主动释放 lock1 资源时，它才会放弃对该资源的持有权，这构成了资源的不可剥夺条件 。线程 1 持有 lock1 并等待获取 lock2 ，而线程 2 持有 lcok2 资源并等待 lock1 资源，这构成了环路等待条件 。

如何定位死锁

利用 jstack 查看线程 pid
利用 JMX 的 ThreadMXBean

public class ThreadMXBeanDetection implements Runnable {

    int flag = 1;

    static Object lock1 = new Object();
    static Object lock2 = new Object();

    public static void main(String[] args) throws InterruptedException {
        ThreadMXBeanDetection r1 = new ThreadMXBeanDetection();
        ThreadMXBeanDetection r2 = new ThreadMXBeanDetection();
        r1.flag = 1;
        r2.flag = 0;
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
        if (deadlockedThreads != null && deadlockedThreads.length > 0) {
            for (long deadlockedThread : deadlockedThreads) {
                ThreadInfo threadInfo = threadMXBean.getThreadInfo(deadlockedThread);
                System.out.println("发现死锁" + threadInfo.getThreadName());
            }
        }
    }

    @Override
    public void run() {
        System.out.println("flag = " + flag);
        if (flag == 1) {
            synchronized (lock1) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("线程1成功拿到两把锁");
                }
            }
        }
        if (flag == 0) {
            synchronized (lock2) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("线程2成功拿到两把锁");
                }
            }
        }
    }
}

修复死锁的策略

避免策略

改变获取锁的顺序，避免相反的获取锁的顺序。

修改之前转账示例的代码：

public class TransferMoney implements Runnable {

    int flag = 1;
    static Account a = new Account(500);
    static Account b = new Account(500);
    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        TransferMoney r1 = new TransferMoney();
        TransferMoney r2 = new TransferMoney();
        r1.flag = 1;
        r2.flag = 0;
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("a的余额" + a.balance);
        System.out.println("b的余额" + b.balance);
    }

    @Override
    public void run() {
        if (flag == 1) {
            transferMoney(a, b, 200);
        }
        if (flag == 0) {
            transferMoney(b, a, 200);
        }
    }

    public static void transferMoney(Account from, Account to, int amount) {
        class Helper {

            public void transfer() {
                if (from.balance - amount < 0) {
                    System.out.println("余额不足，转账失败。");
                    return;
                }
                from.balance -= amount;
                to.balance = to.balance + amount;
                System.out.println("成功转账" + amount + "元");
            }
        }
        // 通过hashCode来决定获取锁的顺序
        int fromHash = System.identityHashCode(from);
        int toHash = System.identityHashCode(to);
        if (fromHash < toHash) {
            synchronized (from) {
                synchronized (to) {
                    new Helper().transfer();
                }
            }
        } else if (fromHash > toHash) {
            synchronized (to) {
                synchronized (from) {
                    new Helper().transfer();
                }
            }
        } else {
            // 如果发生哈希冲突，则需要进行“加时赛”
            synchronized (lock) {
                synchronized (to) {
                    synchronized (from) {
                        new Helper().transfer();
                    }
                }
            }
        }
    }

    static class Account {

        public Account(int balance) {
            this.balance = balance;
        }

        int balance;
    }
}

为了避免哈希冲突，可以使用主键，一般主键是唯一的。

检测与修复策略

一段时间检测是否有死锁，如果有就剥夺某一个资源，来打开死锁。

恢复方法1：进程终止

逐个终止线程，直到死锁消除。

终止顺序：

优先级（是前台交互还是后台处理）
已占用资源、还需要的资源
已经运行时间

恢复方法2：资源抢占

把已经分发出去的锁给收回来。让线程回退几步，这样就不用结束整个线程，成本比较低。

缺点：可能同一个线程一直被抢占，那就造成饥饿

鸵鸟策略

鸵鸟这种动物在遇到危险的时候，通常就会把头埋在地上，这样一来它就看不到危险了。而蛇鸟策略的意思就是说，如果我们发生死锁的概率极其低，那么我们就直接忽略它，直到死锁发生的时候，再人工修复。

如何避免死锁

1、设置超时时间，利用Lock 的 tryLock(long timeout, TimeUnit unit)方法。

public class TryLockDeadlock implements Runnable {

    int flag = 1;
    static Lock lock1 = new ReentrantLock();
    static Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        TryLockDeadlock r1 = new TryLockDeadlock();
        TryLockDeadlock r2 = new TryLockDeadlock();
        r1.flag = 1;
        r2.flag = 0;
        new Thread(r1).start();
        new Thread(r2).start();
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (flag == 1) {
                try {
                    if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
                        System.out.println("线程1获取到了锁1");
                        Thread.sleep(new Random().nextInt(1000));
                        if (lock2.tryLock(800, TimeUnit.MILLISECONDS)) {
                            System.out.println("线程1获取到了锁2");
                            System.out.println("线程1成功获取到了两把锁");
                            lock2.unlock();
                            lock1.unlock();
                            break;
                        } else {
                            System.out.println("线程1尝试获取锁2失败，已重试");
                            lock1.unlock();
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    } else {
                        System.out.println("线程1获取锁1失败，已重试");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (flag == 0) {
                try {
                    if (lock2.tryLock(3000, TimeUnit.MILLISECONDS)) {
                        System.out.println("线程2获取到了锁2");

                        Thread.sleep(new Random().nextInt(1000));
                        if (lock1.tryLock(3000, TimeUnit.MILLISECONDS)) {
                            System.out.println("线程2获取到了锁1");
                            System.out.println("线程2成功获取到了两把锁");
                            lock1.unlock();
                            lock2.unlock();
                            break;
                        } else {
                            System.out.println("线程2尝试获取锁1失败，已重试");
                            lock2.unlock();
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    } else {
                        System.out.println("线程2获取锁2失败，已重试");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2、多使用并发类而不是自己设计锁。

3、尽量降低锁的使用粒度：用不同的锁而不是一个锁。

4、如果能使用同步代码块，就不使用同步方法。

5、给你的线程起个有意义的名字：debug 和排查时事半功倍，框架和 JDK 都遵守这个最佳实践。

6、避免锁的嵌套。

7、分配资源前先看能不能收回来：银行家算法。

8、尽量不要几个功能用同一把锁：专锁专用。

活锁

线程主动将资源释放给他人使用，那么就会导致资源不断地在两个线程间跳动，而没有一个线程可以同时拿到所有资源正常执行，这种情况就是活锁。

public class LiveLock {

    static class Spoon {

        private Diner owner;

        public Spoon(Diner owner) {
            this.owner = owner;
        }

        public Diner getOwner() {
            return owner;
        }

        public void setOwner(Diner owner) {
            this.owner = owner;
        }

        public synchronized void use() {
            System.out.printf("%s吃完了!", owner.name);


        }
    }

    static class Diner {

        private String name;
        private boolean isHungry;

        public Diner(String name) {
            this.name = name;
            isHungry = true;
        }

        public void eatWith(Spoon spoon, Diner spouse) {
            while (isHungry) {
                if (spoon.owner != this) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    continue;
                }
                
                if (spouse.isHungry) {
                    System.out.println(name + ": 亲爱的" + spouse.name + "你先吃吧");
                    spoon.setOwner(spouse);
                    continue;
                }

                spoon.use();
                isHungry = false;
                System.out.println(name + ": 我吃完了");
                spoon.setOwner(spouse);

            }
        }
    }


    public static void main(String[] args) {
        Diner husband = new Diner("牛郎");
        Diner wife = new Diner("织女");

        Spoon spoon = new Spoon(husband);

        new Thread(new Runnable() {
            @Override
            public void run() {
                husband.eatWith(spoon, wife);
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                wife.eatWith(spoon, husband);
            }
        }).start();
    }
}

上述代码会无限执行下去。

解决方案：加入随机因素，使其退出互相谦让。还有其他如以太网的指数退避算法。

// 随机因素
Random random = new Random();
if (spouse.isHungry && random.nextInt(10) < 9) {
    System.out.println(name + ": 亲爱的" + spouse.name + "你先吃吧");
    spoon.setOwner(spouse);
    continue;
}

工作中的活锁：消息队列

如果消息如果处理失败，就放在队列头重试，那么可能处理该消息一直失败。虽然没阻塞，但程序无法继续。

解决方案：放在队尾或者添加重试机制，比如重试超过一定次数，就把该任务放入数据库，数据库检测到新的任务，那么后续定时任务会尝试继续执行该任务。

饥饿

饥饿指某一个或者多个线程因为种种原因无法获得所需要的资源，导致一直无法执行。比如它的线程优先级可能太低，而高优先级的线程不断抢占它需要的资源，导致低优先级线程无法工作。与死锁相比，饥饿还是有可能在未来一段时间内解决的（比如，高优先级的线程已经完成任务，不再疯狂执行）。

知识不加糖

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
出现死锁问题怎么解决？

什么是死锁每个线程都在等待对方线程释放锁，然而谁都不主动释放锁，结果就构成死锁。死锁的影响在不同系统中是不一样的，这取决于系统对死锁的处理能力。数据库：检测并放弃事务。JVM ：无法自动处理。发生死锁的例子经典死锁public class DeadLock implements Runnable { int flag = 1; static Object lock1 = new Object(); static Object lock2 = new Object()
复制链接

扫一扫