【Java并发】死锁

最新推荐文章于 2023-08-15 17:50:24 发布

zcz5566719

最新推荐文章于 2023-08-15 17:50:24 发布

阅读量117

点赞数

分类专栏： Java并发解析文章标签： java 面试多线程

本文链接：https://blog.csdn.net/zcz5566719/article/details/108371250

版权

Java并发解析专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

什么是死锁
发生死锁的条件
死锁的修复
实际工程中如何避免死锁
其他活跃性问题
- 活锁
- 饥饿
面试问题

什么是死锁

什么是死锁：
发生在并发中，两者互不相让，互相持有对方所需要的资源，又不主动释放，导致程序卡死。
死锁的影响
死锁的影响在不同的系统中不同的。在数据库中就是可以检测并且放弃事务的。但是JVM无法自动处理死锁。

死锁发生的几率不高但是危害大，压力测试无法找出所有的潜在死锁。

发生死锁的条件

互斥条件
请求与保持条件
不剥夺条件
循环等地条件。

图解Java并发设计认为三点

存在多个资源块
线程持有某个资源块时还希望获得其他的资源块
获取资源的顺序并不固定。

死锁的修复

可以采用ThreadMXBean这一工具类。

        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
        if (deadlockedThreads != null && deadlockedThreads.length>0){
            for (int i = 0; i < deadlockedThreads.length; i++) {
                ThreadInfo threadInfo = threadMXBean.getThreadInfo(deadlockedThreads[i]);
                System.out.println("find "+threadInfo.getThreadName());
            }
        }

实际工程中如何避免死锁

线上问题都需要防患于未然，无法线上及时的修复
首先需要保存现场，保存堆栈的信息，然后重启服务器等。首先保证用户的体验。
暂时保证线上代码的安全，利用保存的堆栈信息等，排查死锁，修改代码。

修复策略：

避免策略：哲学家就餐，设置一致的锁的获取顺序。
检测与恢复策略：每隔一段时间检测是否有死锁，如果有就剥夺某一个资源，打开死锁。
鸵鸟策略：直到发生死锁，再进行修复。

以哲学家就餐问题为例

参考

public class test {

    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        int sum = 5;
        Chopstick[] chopsticks = new Chopstick[sum];
        for (int i = 0; i < sum; i++) {
            chopsticks[i] = new Chopstick();
        }
        for (int i = 0; i < sum; i++) {
            exec.execute(new Philosopher(chopsticks[i], chopsticks[(i + 1) % sum]));
        }
    }
}

// 筷子
class Chopstick {
    public Chopstick() {
    }
}
class Philosopher implements Runnable {

    private Chopstick left;
    private Chopstick right;

    public Philosopher(Chopstick left, Chopstick right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        try {
            while (true) {
                Thread.sleep(100);//思考一段时间
                System.out.println(Thread.currentThread().getName() + " " + "Think");
                synchronized (left) {
                    System.out.println(Thread.currentThread().getName() + " " + "left");
                    synchronized (right) {
                        System.out.println(Thread.currentThread().getName() + " " + "right");
                        Thread.sleep(1000);//进餐一段时间
                    }
                }
            }
        }
        catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}