多线程——死锁

最新推荐文章于 2025-11-18 12:08:39 发布
原创 最新推荐文章于 2025-11-18 12:08:39 发布 · 1.1k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #java-ee

在我们使用多线程进行开发的时候，不可避免的会碰上死锁这类的问题，而这是我们在使用多线程中最常见的也是最棘手的问题，这篇文章就带你们初步的了解一下什么是死锁，以及如何避免死锁的产生。

一、什么是死锁

每次当别人问我什么是死锁的时候，我都会举一个每次说出来大家都觉得很好笑的例子，虽然有点老套，但真的很符合我们对死锁的定义。假设你要上班，发现没带车钥匙，车钥匙忘在家里了，但很不巧的是开门的钥匙在车里，这个时候就是悲剧的发生了~也就是触发了死锁！

通过这个例子我们可以把诱发死锁的条件用图画的形式表现出来：

首先是资源被线程给占用，导致其它线程无法使用这个资源

 那就有小伙伴问了，那也还好啊，等线程一把资源用完，那线程二不就可以用了吗。这不是也避免了出现线程安全的问题吗？但线程安全问题跟死锁的本质并不是一样，线程安全是可以通过我们使用的技术进行处理，但死锁会将程序变得不能运行，是一个bug！而且是很严重的恶性bug！

还是举一个十分生动的例子，我们在日常生活中也要搬各种各样的物品，我们有时候就会陷入一种两难的境地，最经典的就是你的右手托着一叠盘子，左手托着一摞碗，等你要将盘子放在桌子上的时候，需要用左手帮你把盘子拿起来，但是你的左手却没有空余的操作空间，这个时候想必你只能傻傻的呆在原地等待其他人的帮助吧，这也是博主的亲身经历，所以经过这件事以后，我对死锁的执念非常深，因为它确确实实影响到了我的生活，这就是典型的死锁！

那这个死锁和我们上面画的“线程兄弟”有什么区别呢？答案是线程二中没有线程一想要的资源，那么线程二可以等待线程一使用完后就可以接着使用资源了，我们可以换个场景，还是这俩难兄难弟！

我们可以通过图示发现，当两个线程都想要读取其他线程占用的资源的时候，就会出现堵塞并等待，等待其他线程使用完，而其它线程也会这么想，那就会造成严重的死锁现象！所以我们可以总结出以下几点死锁的诱发条件：

1.互斥使用：当资源被一个线程占用时，其它线程不可以使用该资源。

2.不可抢占：请求资源不可以从占有者手里抢占，必须等待占有者主动释放。

3.请求和保持：资源请求者在请求其它资源的时候同时，保持对原用资源的占有。

4.循环等待：各个线程对资源占用实现一个环路结构，P1占用P2资源，P2占用P3资源，P3占用P1资源。 

这些都完美符合我们上述图例的条件，所以我们的图示中“线程兄弟”就开始吵得不可开交了。

那我们该怎么帮助他们解决死锁的问题呢？

二、如何避免死锁

 在上面的图示中，“线程兄弟”之所以吵架，就是因为满足了死锁触发的所有条件，那如果我们修改其中一个条件，那是不是就把死锁破坏了，也就恢复正常了。

public class DeadLock1 {
    static class Banana {
        public Banana() {
        }
    }

    static class Apple {
        public Apple() {
        }
    }


    public static void main(String[] args) throws InterruptedException {
        Banana banana = new Banana();
        Apple apple = new Apple();

        Thread threadOlderBrother = new Thread() {
            @Override
            public void run() {
               synchronized (banana) {
                   System.out.println("大哥有香蕉");
                   try {
                       Thread.sleep(1000);
                       synchronized (apple) {
                           System.out.println("大哥拿到苹果");
                       }
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }

            }
        };

        ;


        Thread threadYoungerBrother = new Thread() {
            @Override
            public void run() {
                synchronized (apple) {
                    System.out.println("小弟有苹果");
                    try {
                        Thread.sleep(1000);
                        synchronized (banana) {
                            System.out.println("小弟拿到香蕉");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        };

        // 线程兄弟同时开始
        threadOlderBrother.start();
        threadYoungerBrother.start();

        // 线程兄弟同时结束
        threadOlderBrother.join();
        threadYoungerBrother.join();
    }
}

我们用一串代码来表示我们的提到的“线程兄弟”吵架的场景，当我们执行代码的时候就会发现我们的拿到XX无法正常打印出来！

而我们的程序是没有显示异常中止的！我们可以发现引起死锁的原因是我们进行了嵌套锁定。

有时候我们要在一些场景下避免锁嵌套，我们可以跟“线程兄弟”商量说，大哥可以先用香蕉，用完香蕉直接拿出来，小弟就可以直接用香蕉了。那我们可以在原来的基础上修改我们的实现代码，我们可以把嵌套的锁拿到外面，用完就直接销毁，不会影响上锁代码块以外的代码。

public class DeadLock1 {
    static class Banana {
        public Banana() {
        }
    }

    static class Apple {
        public Apple() {
        }
    }


    public static void main(String[] args) throws InterruptedException {
        Banana banana = new Banana();
        Apple apple = new Apple();

        Thread threadOlderBrother = new Thread() {
            @Override
            public void run() {
               synchronized (banana) {
                   System.out.println("大哥有香蕉");
                   try {
                       Thread.sleep(1000);
                       System.out.println("大哥拿出香蕉");
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
                synchronized (apple) {
                    System.out.println("大哥拿到苹果");
                }
            }
        };

        ;


        Thread threadYoungerBrother = new Thread() {
            @Override
            public void run() {
                synchronized (apple) {
                    System.out.println("小弟有苹果");
                    try {
                        Thread.sleep(1000);
                        System.out.println("小弟拿出苹果");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (banana) {
                        System.out.println("小弟拿到香蕉");
                    }
                }
            }
        };

        // 线程兄弟同时开始
        threadOlderBrother.start();
        threadYoungerBrother.start();

        // 线程兄弟同时结束
        threadOlderBrother.join();
        threadYoungerBrother.join();
    }
}

我们可以看到”线程兄弟“终于重归于好了，我们破坏的是之前提到的死锁条件的第三点，请求和保持。

但我们要注意的是，条件一和条件二都是有关线程安全的，如果在特定场景中是不能去进行此类操作的，因为有可能会引发线程安全问题！

那么，我们可以通过条件三和条件四着手：

public class DeadLock2 {

    public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Object lock2 = new Object();
        Object lock3 = new Object();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // t1拿了t2的锁
                synchronized (lock2) {
                    try {
                        Thread.sleep(1000);
                        synchronized (lock1) {
                            System.out.println("获得t1锁");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // t2拿了t3的锁
                synchronized (lock3) {
                    try {
                        Thread.sleep(1000);
                        synchronized (lock2) {
                            System.out.println("获得t1锁");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                // t3拿了t1的锁
                synchronized (lock1) {
                    try {
                        Thread.sleep(1000);
                        synchronized (lock3) {
                            System.out.println("获得t1锁");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();
    }
}

我们又写了一个死锁代码，这是因为循环队列导致的环路等待，我们只要把条件破坏掉就可以避免死锁的产生，我们可以将锁计时，超过时间就自动下锁，这样就避免了条件四的触发。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class DeadLock2 {

    public static void main(String[] args) throws InterruptedException {
        Lock lock1 = new ReentrantLock();
        Lock lock2 = new ReentrantLock();
        Lock lock3 = new ReentrantLock();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // t1拿了t2的锁
                try {
                    // 获取t2锁
                    if(lock2.tryLock()) {
                        try {
                            Thread.sleep(1000);
                            System.out.println("t1获得t2锁");
                        } finally {
                            lock2.unlock();
                            Thread.sleep(1000);
                            // 设置解锁
                            if(lock1.tryLock()) {
                                System.out.println("t1获得t1锁");
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // t2拿了t3的锁
                try {
                    // 获取t3锁
                    if(lock3.tryLock()) {
                        try {
                            Thread.sleep(1000);
                            System.out.println("t2获得t3锁");
                        } finally {
                            lock3.unlock();
                            Thread.sleep(1000);
                            // 设置解锁
                            if(lock2.tryLock()) {
                                System.out.println("t2获得t2锁");
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                // t3拿了t1的锁
                try {
                    // 获取t1锁
                    if(lock1.tryLock()) {
                        try {
                            Thread.sleep(1000);
                            System.out.println("t3获得t1锁");
                        } finally {
                            lock1.unlock();
                            Thread.sleep(1000);
                            // 设置解锁
                            if(lock3.tryLock()) {
                                System.out.println("t3获得t3锁");
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();
    }
}

我们将锁设置了时间，过了1秒自动下锁，避免了占用资源导致条件三和四的产生！

 

如果我们两个线程中的锁对象都是一样的，那可以调整上锁的顺序避免出现死锁的情况：

public class DeadLock3 {
    public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("我是线程一");
                }
            }
        });

        Thread t2 = new Thread(() -> {
           synchronized (lock2) {
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               synchronized (lock1) {
                   System.out.println("我是线程二");
               }
           }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();
    }
}

我们现在写了一个获取锁对象顺序不同的代码，运行以后就会发生死锁现象，这个时候我们要改变获取锁对象的顺序，来避免发生死锁的情况：

public class DeadLock3 {
    public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("我是线程一");
                }
            }
        });

        Thread t2 = new Thread(() -> {
           synchronized (lock1) {
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               synchronized (lock2) {
                   System.out.println("我是线程二");
               }
           }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();
    }
}

现在我们将线程一和线程二获取锁对象的顺序调成一样的情况就可以避免发生死锁，在我们的日常生产中也有可能要使用到多线程开发的情况，那我们就得使用这些小技巧来避免发生死锁的情况。

三、总结

博主已经浅浅地介绍了死锁的相关内容，但我们在实际开发中，可能会遇到更特殊的情况，比如我们在不同类里调用锁对象，可能会导致死锁，但不能第一时间就找到问题所在，因为不知道是哪个几个类资源占用引发死锁现象。或者是在第三方依赖里面有全局的锁对象导致的死锁发生。我们都可以通过以上方法进行排查和修复，但由于死锁出现的位置往往不在一个类甚至文件中，所以需要花大量时间来修复，所以我们在设计多线程的程序时，要注重程序的健壮性，确保获取锁对象的顺序以及避免设计出全局锁对象，尽可能使用局部锁对象。这就是我对于死锁个人见解，如有出错，还希望各位指出。 

多线程之死锁
我的E家
04-02 533
死锁产生原因 当两个或者多个线程互相持有一定资源，并互相等待其他线程释放资源而形成的一种僵局，就是死锁。例如： 一个线程持有A资源，希望使用B资源，而另一个线程持有B资源，希望使用A资源，然后就陷入了相互等待的僵局，这样就形成了死锁。 多个线程涉及到多个锁，这些锁存在着交叉，所以可能会导致了一个锁依赖的闭环。 代码构造死锁场景 public class ...
【线程安全】死锁问题及解决方案
程序猿教你打篮球的博客
05-01 7424
本期主要讲解： 1.什么是死锁 2.死锁的三个典型情况 2.1—个线程─把锁 2.2两个线程两把锁 2.3多个线程多把锁 3.如何避免死锁 3.1产生死锁的四个必要条件 3.2打破循环等待
Java多线程死锁示例
08-27
主要介绍了Java多线程死锁,结合实例形式分析了Java多线程出现死锁的相关原因与操作注意事项,需要的朋友可以参考下
死锁
W_Meng_Xin的博客
03-02 239
死锁 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁问题” //死锁：多个线程互相抱着对方需要的资源，然后形成僵持 public class DeadLock { public static void main(String[] args) { Makeup g1 = new Makeup(0,"小红"); Makeu
什么是多线程死锁，如何预防和解决？
最新发布
X13100387636的博客
11-18 519
多线程死锁是多个线程因相互持有对方所需资源而陷入无限等待的状态。本文通过Java代码示例演示了死锁场景，并提出四种解决方案：1）固定资源获取顺序（破坏循环等待）；2）一次性获取所有资源（破坏持有并等待）；3）使用超时机制（破坏不可剥夺）；4）定期检测与恢复。其中按固定顺序获取资源是最常用的预防方法。这些方法通过破坏死锁四大必要条件（互斥、持有并等待、不可剥夺、循环等待）来避免死锁发生。
线程死锁
代码学习之路的博客
06-29 198
1.1.什么是线程死锁? 多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。 如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。 下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》)： public class Dea...
多线程—— (4) 死锁
真香号
08-14 692
死锁：举个栗子，两个人面对面过独木桥，甲和乙都已经在桥上走了一段距离，即占用了桥的资源，甲如果想通过独木桥的话，乙必须退出桥面让出桥的资源，让甲通过，但是乙不服，为什么让我先退出去，我还想先过去呢，于是就僵持不下，导致谁也过不了桥，这就是死锁。   死锁：最常见的情景之一 ：同步的嵌套 class Ticket implements Runnable { private int num...
多线程——死锁和线程通信
weixin_65572588的博客
11-03 725
死锁：在多线程程序中,使用了多把锁,造成线程之间相互等待.程序不往下走了。造成死锁的原因1.多个线程间，相互持有对方的对象锁2.同步代码块嵌套如何排查死锁问题1.命令终端通过 CMD 进入，输入 jps -l ，查看进程，锁定进程号通过 jstack 进程号 ，进一步去锁定 Found 1 deadlock. 的问题2.图形化方式通过jconsole命令进入，选择当前类的进程，找到线程的选项卡->检测死锁如何解决问题1.不要同步代码块嵌套。
Java多线程遇到死锁三招彻底解决
技术专家
11-25 2547
Java多线程遇到死锁三招彻底解决多次岸城
【多线程】c++11多线程编程(四)——死锁(Dead Lock)
小鱼菜鸟的博客
05-13 166
死锁 如果你将某个mutex上锁了，却一直不释放，另一个线程访问该锁保护的资源的时候，就会发生死锁，这种情况下使用lock_guard可以保证析构的时候能够释放锁(RAII技术)，然而，当一个操作需要使用两个互斥元的时候，仅仅使用lock_guard并不能保证不会发生死锁，如下面的例子： #include <iostream> #incl...
线程同步——死锁分析及处理方式
weixin_43277501的博客
09-27 294
一、死锁的定义多线程以及多进程改善了系统资源的利用率并提高了系统 的处理能力。然而，并发执行也带来了新的问题——死锁。所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。二、死锁产生的原因1) 系统资源的竞争通常系统中拥有的不可剥夺资源，其数量不足以满足多个进程...
多线程的死锁
weixin_42481364的博客
09-02 469
死锁 死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 在两个或多个任务中，如果每个任务锁定了其他任务试图锁定的资源，此时会造成这些任务永久阻塞，从而出现死锁。例如：事务A 获取了行 1 的共享锁。事务 B 获取了行 2 的共享锁。 虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件。 互
多线程——“死锁”
HKJ_numb1的博客
09-24 2221
“死锁”是多线程代码中一类常见的问题，加锁是能解决线程安全的问题，但是如果加锁的方式不当，就可能产生“死锁”，本篇文章就会对“死锁”的三个比较常见的场景进行介绍。 当你在编程过程中，使用的锁是不可重入锁，并且在同一个线程中对同一把锁进行两次加锁，此时就可能面临“死锁”的状况
【多线程】死锁
爱编程爱运动的博客
09-06 4870
本期内容主要介绍死锁的三种情况，以及造成死锁的4个必要条件，最后介绍5种避免死锁的方式。
Java多线程——死锁
u010759175的专栏
12-28 1274
话不多说先来个例子说明 灰姑娘和白雪公主化妆，但是同时拿着对方的资源不释放，形成了僵持的局面 //死锁：多个线程互相抱着对方需要的资源，形成僵持 public class DeadLock { public static void main(String[] args) { MakeUp m1 = new MakeUp(0,"灰姑娘"); MakeUp m2 = new MakeUp(1,"白雪公主"); m1.start(); m2.start(); } } //口红 class
多线程Lock锁实现线程同步
qq_35657661的博客
12-19 799
在之前的文章中，使用synchronized同步代码块， wait(); notify();解决了线程同步问题，那么除了这个办法，还可以使用lock锁。还是之前的例子： lock用法如下： Lock lock = new ReentrantLock(); lock.lock(); try{ //可能会出现线程安全的操作 }finally{ //一定在finally中释放锁 //也不能把获取锁在t...
多线程22-死锁
angel56789的博客
03-08 183
死锁 多个线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁"时，就可能会发生”死锁“的问题 package com.faq.syn; //死锁：多个线程相互抱着对方需要的资源，然后形成僵持 public class DeadLock { public static void main(String[] args) { Makeup g1 = new Makeup(0
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

comerun

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值