线程死锁问题

最新推荐文章于 2023-07-07 16:18:59 发布
最新推荐文章于 2023-07-07 16:18:59 发布
阅读量129 收藏
点赞数
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suchenbin/article/details/101633200
版权

多线程时容易出现线程安全问题，其中一种解决方法是使用锁，但是加锁很可能带来另外一个线程安全问题——死锁。

死锁的概念（来自百度百科）

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

死锁产生的条件（来自百度百科）

1）互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。

2）请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。

3）不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。

4）环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

死锁解决方法

解决死锁最好的方式就是不让死锁产生，也就是说只要不让死锁产生的四个条件同时满足就行了。

1）、确定获取资源（锁）的顺序；

2）、采用尝试获取锁的机制。

简单死锁

例：假设需要同时获得笔和纸才能画画，且现在只有一支笔和一张纸，小明和小芳想画画，我们这里设置了两把锁，所以对应获得笔，锁2对应获得纸，小明和小芳去获取锁，小明获得了锁1（笔），小芳获得了锁2（纸），如果他们都不愿意放弃获得的锁（笔/纸），意味着对方永远无法获得缺少的锁（纸/笔），都不能画画。这就是死锁。

代码：

package com.su.mybatis.oracle.controller;

public class Test {

    //锁1
    private static Object obj1 = new Object();

    //锁2
    private static Object obj2 = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj1) {
                    getPen();
                    synchronized (obj2) {
                        getPaper();
                        System.out.println(Thread.currentThread().getName() + "：画画");
                    }
                }
            }
        });
        t1.setName("小明");
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj2) {
                    getPaper();
                    synchronized (obj1) {
                        getPen();
                        System.out.println(Thread.currentThread().getName() + "：画画");
                    }
                }
            }
        });
        t2.setName("小芳");
        t2.start();
    }
    
    public static void getPen() {
        try {
            Thread.sleep(1500);
            System.out.println(Thread.currentThread().getName() + "：获得笔");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void getPaper() {
        try {
            Thread.sleep(1500);
            System.out.println(Thread.currentThread().getName() + "：获得纸");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

程序会一直运行，运行结果：

小明：获得笔
小芳：获得纸

对于这种死锁情况怎么样解决呢？很简单。只需要将小明小芳拿两个锁的顺序改成一致即可。

package com.su.mybatis.oracle.controller;

public class Test {

    //锁1
    private static Object obj1 = new Object();

    //锁2
    private static Object obj2 = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj1) {
                    getPen();
                    synchronized (obj2) {
                        getPaper();
                        System.out.println(Thread.currentThread().getName() + "：画画");
                    }
                }
            }
        });
        t1.setName("小明");
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj1) {
                    getPen();
                    synchronized (obj2) {
                        getPaper();
                        System.out.println(Thread.currentThread().getName() + "：画画");

                    }
                }
            }
        });
        t2.setName("小芳");
        t2.start();
    }
    
    public static void getPen() {
        try {
            Thread.sleep(1500);
            System.out.println(Thread.currentThread().getName() + "：获得笔");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void getPaper() {
        try {
            Thread.sleep(1500);
            System.out.println(Thread.currentThread().getName() + "：获得纸");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

小明：获得笔
小明：获得纸
小明：画画
小芳：获得笔
小芳：获得纸
小芳：画画

当然，这里只需要考虑小明和小芳获得锁的顺序，至于获得锁后是获得笔还是获得纸都是不影响的。

动态的死锁

一个经典的问题--转账。

package com.su.mybatis.oracle.controller;

public class Test {

    public static void main(String[] args) {
        User xiaoming = new User("小明", "A1", 20000);//小明，账号A1,20000元
        User xiaofang = new User("小芳", "A2", 15000);//小芳，账号A2,15000元
        Thread t1 = new ThreadTest(xiaoming,xiaofang,3000);//小明转账3000给小芳
        t1.setName("小明");
        t1.start();

        Thread t2 = new ThreadTest(xiaofang,xiaoming,2000);//小芳转账2000给小明
        t2.setName("小芳");
        t2.start();
    }
}

class ThreadTest extends Thread{
    private User sourceUser;
    private User destUser;
    private int money;
    
    public ThreadTest(User sourceUser, User destUser, int money) {
        this.sourceUser = sourceUser;
        this.destUser = destUser;
        this.money = money;
    }
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        synchronized (sourceUser) {//来源（转出钱的账号）
            try {
                System.out.println(threadName + "获得锁1");
                Thread.sleep(1500);
                sourceUser.setMoney(sourceUser.getMoney() - money);
                synchronized (destUser) {//目的地（转入钱的账号）
                    System.out.println(threadName + "获得锁2");
                    destUser.setMoney(destUser.getMoney() + money);
                    System.out.println(threadName + "转账完成");
                    System.out.println("source:" + sourceUser.toString());
                    System.out.println("dest:" + destUser.toString());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class User{
    public User(String name, String amount, int money) {
        this.name = name;
        this.amount = amount;
        this.money = money;
    }
    private String name;
    private String amount;
    private int money;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAmount() {
        return amount;
    }
    public void setAmount(String amount) {
        this.amount = amount;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    
    @Override
    public String toString() {
        return "name:" + name + ",amount:" + amount + ",money:" + money;
    }
}

运行结果：

小明获得锁1
小芳获得锁1

解决方法：使用显示锁中尝试获取锁的机制（方法不止一种）。只有同时获取到两把锁的时候，才执行转账业务。如果获得第一把锁后，没有获取到第二把锁，则释放第一把锁，然后重新尝试。因为存在反复尝试的过程，所以会使用到while 循环，使用break跳出循环，跳出循环的条件是转账完成。

package com.su.mybatis.oracle.controller;

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {

    public static void main(String[] args) {
        User xiaoming = new User("小明", "A1", 20000);// 小明，账号A1,20000元
        User xiaofang = new User("小芳", "A2", 15000);// 小芳，账号A2,15000元
        Thread t1 = new ThreadTest(xiaoming, xiaofang, 3000);// 小明转账3000给小芳
        t1.setName("小明");
        t1.start();

        Thread t2 = new ThreadTest(xiaofang, xiaoming, 2000);// 小芳转账2000给小明
        t2.setName("小芳");
        t2.start();
    }
}

class ThreadTest extends Thread {
    private User sourceUser;
    private User destUser;
    private int money;

    public ThreadTest(User sourceUser, User destUser, int money) {
        this.sourceUser = sourceUser;
        this.destUser = destUser;
        this.money = money;
    }

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        while (true) {
            if (sourceUser.getLock().tryLock()) {// 来源（转出钱的账号）
                System.out.println(threadName + "获得锁1");
                try {
                    if (destUser.getLock().tryLock()) {// 目的地（转入钱的账号）
                        try {
                            sourceUser.setMoney(sourceUser.getMoney() - money);
                            destUser.setMoney(destUser.getMoney() + money);
                            System.out.println(threadName + "转账完成");
                            System.out.println("source:" + sourceUser.toString());
                            System.out.println("dest:" + destUser.toString());
                            break;
                        } finally {
                            destUser.getLock().unlock();
                        }
                    }
                } finally {
                    sourceUser.getLock().unlock();
                }
            }
            try {
                Thread.sleep( new Random().nextInt(5));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class User {
    public User(String name, String amount, int money) {
        this.name = name;
        this.amount = amount;
        this.money = money;
    }

    private String name;
    private String amount;
    private int money;

    private final Lock lock = new ReentrantLock();

    public Lock getLock() {
        return lock;
    }

    public String getName() {
        return name; 
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAmount() {
        return amount;
    }

    public void setAmount(String amount) {
        this.amount = amount;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "name:" + name + ",amount:" + amount + ",money:" + money;
    }
}

输出结果：

小明获得锁1
小芳获得锁1
小芳转账完成
source:name:小芳,amount:A2,money:13000
dest:name:小明,amount:A1,money:22000
小明获得锁1
小明转账完成
source:name:小明,amount:A1,money:19000
dest:name:小芳,amount:A2,money:16000

Thread.sleep( new Random().nextInt(5))的作用：

让线程进行短暂休眠，使它们错开拿锁时间，减少尝试拿锁过程中的碰撞，杜绝活锁的产生，避免资源（eg：CPU等）的浪费。

活锁：并发编程中，线程没有被阻塞，因为某些必要条件不满足，一直处于尝试获取资源（eg：锁）→获取资源失败→尝试获取资源...的过程。活锁状态的线程会不断的改变状态，需要消耗一定的资源，活锁有可能自行解开（将Thread.sleep( new Random().nextInt(5))注掉运行即可复现）。

 

 

如果有写的不对的地方，请大家多多批评指正，非常感谢！

黑衣如墨剑如雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程的死锁问题
m0_49151953的博客
04-25 104
死锁问题： 1.什么时候会出现死锁？ 线程A进入同步方法1（拿到同步锁1）线程B进入同步方法2（拿到同步锁2），1方法中有一个嵌套同步方法（需要同步锁2）2方法中有一个嵌套同步方法（需要同步锁1），只是就可能会引发死锁问题线程A需要锁2，线程B需要锁1，但是两个线程都没执行完无法释放锁，就僵持住了都在等对方释放锁，就形成了死锁。 注意：同步方法和同步代码块只允许单个线程访问，在线程进入时拿到锁，在执行完方法体后释放，无法手动关锁开锁。 wait(),notify(),notifyAll()的使用(.
线程中的死锁问题
raoshihong的专栏
12-04 768
线程中的死锁都是发生在多个线程中的，多个线程中存在多个同步锁，这几个线程相互索取对方锁的钥匙造成的僵持局面 多个线程中的多个同步锁，先后索取对方锁的钥匙时，有时也会出现和谐的状态，如两个人吵架，相互不让，结果某一刻突然相互
线程死锁问题以及简单案例分析
@素素~的博客
03-06 425
线程死锁问题以及简单案例分析1. 什么是死锁？1.1 概述1.2. 业务场景——举例说明2. 死锁例子2.1 代码2.2 效果2.3 代码分析3. 解决案例中死锁问题4. 怎么避免线程死锁？ 1. 什么是死锁？ 1.1 概述 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程死锁。 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续！ 1.2. 业务场景——举例说明 举例说明： 比如两个小情侣刚开始感情很好，还弄了一个公共财神卡，
Java Swing多线程死锁问题解析
08-10
Java Swing多线程死锁问题解析 Java Swing多线程死锁问题解析是Java开发者经常遇到的问题之一。在基于Java Swing进行图形界面开发时，经常会遇到多线程问题。如果在图形界面的同一个线程中进行查询和运算工作，则会...
python 多线程死锁问题的解决方案
09-16
主要介绍了python 多线程死锁问题的解决方案，帮助大家更好的理解和学习python 锁，感兴趣的朋友可以了解下
linux多线程死锁问题分析
01-22
在Linux系统中，多线程编程是常见的并发执行方式，然而如果不小心，它可能会引发一些问题，特别是死锁。死锁是指两个或多个线程在等待对方释放资源，导致它们都无法继续执行的状态。在这个特定的案例中，我们看到12...
多线程死锁问题
05-29
本篇文章将深入探讨Java中的死锁问题，并通过提供的代码示例`ProducerConsumer.java`、`TestDeadLock.java`和`Count3Quit.java`来解释如何识别和解决死锁。 首先，我们需要理解死锁的四个必要条件： 1. **互斥**：...
java之多线程(五)——线程死锁问题
最新发布
weixin_42902126的博客
07-07 407
什么是死锁问题 1、不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。 2、出现死锁后，不会出现异常，不会出现提示，知识所有线程都处于阻塞状态，无法继续。 解决方法 1、专门的算法、原则 2、尽量减少同步资源的定义 3、尽量避免嵌套同步 代码实例 public class SouTest { public static void m...
解决线程的死锁问题
小坏蛋博客
08-14 196
在编写多线程程序时，必须注意资源的使用问题。如果两个线程（多个线程类似）分别拥有不同的资源，而同时又需要对方释放资源才能继续运行时，就会发生死锁，本实例演示解决死锁的方式 Java 死锁产生的四个必要条件： 1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用 2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。 3、请求和保持，即当资源请求者在请求...
两个死锁的实例
congbao6525的博客
07-07 153
关于数据库中的死锁。如果在应用中碰到都会毫不犹豫转交给DBA，但是从目前我接到的deadlock的问题来看，和Oracle官方的描述基本都是一致的。 The following deadlock is not an O...
监视线程池 死锁
hailangamy的专栏
11-03 2841
监视线程池 ThreadPool 类提供了两个方法用来查询线程池的状态。第一个是我们可以从线程池获取当前可用的线程数量： public static void GetAvailableThreads(    out int workerThreads,    out int completionPortThreads); 从方法中你可以看到两种不同的线程：          Wor
死锁的成因及其解决办法
qq_46638003的博客
04-02 622
死锁的成因与解决
连续锁定2个不同的锁会死锁_研究死锁–第5部分：使用显式锁定
最佳 Java 编程
06-05 311
连续锁定2个不同的锁会死锁 在我的上一个博客中，我研究了使用Java的传统synchronized关键字和锁排序来修复破碎的，死锁的余额转移示例代码。 但是，有另一种方法称为显式锁定。 在这里，将锁定机制称为显式而非隐式的想法是， 显式表示它不是Java语言的一部分，并且已编写了一些类来实现锁定功能。 另一方面， 隐式锁定可以定义为语言的一部分，并且可以使用语言关键字synchronchi...
手写死锁
pengbo6665631的博客
01-30 762
死锁的概念：多个线程互相持有对方所需要的资源，导致这些线程处于等待状态。 死锁产生的必要条件： 互斥：一个资源只允许一个线程访问（厕所一个坑只能一个人上厕所） 占有且等待：一个线程占有资源，同时还有其他线程未得到满足，正在等待其他线程释放该资源（厕所坑里进了一个人，外面还有一个人等着里面的人厕所用完） 不可抢占：其他线程已经占有了某项资源，不能因为你需要就抢过来（别人已经进坑里上厕所了，不...
多线程死锁的产生以及如何避免死锁
热门推荐
jayxu无捷之径的博客
07-13 11万+
一、死锁的定义 多线程以及多进程改善了系统资源的利用率并提高了系统 的处理能力。然而，并发执行也带来了新的问题——死锁。所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。 下面我们通过一些实例来说明死锁现象。 先看生活中的一个实例，在一条河上有一座桥，桥面很窄，只能容纳一辆汽车通行。如 果有两辆汽车分别从桥的左右两端驶上该桥，则会出现
关于互斥锁的死锁及解决措施
qianqian_0825的博客
05-09 2556
死锁：1、什么是死锁：     一般情况下，如果同一个线程先后两次调用lock，在第二次调用时，由于锁已经被占用，该线程会挂起等待别的线程释放锁，然而锁正是被自己占用着的，该线程又被挂起而没有机会释放锁，因此就永远处于挂起等待状态了，这叫做死锁（Deadlock）。     另一种：若线程A获得了锁1，线程B获得了锁2，这时线程A调用lock试图获得锁2，结果是需要挂起等待线程B释放锁2，而这时线...
死锁的原因及解决办法
爱睡觉的小懒虫
04-12 493
一.什么是死锁？ 　　　死锁是由于两个或以上的线程互相持有对方需要的资源，导致这些线程处于等待状态，无法执行。 二.产生死锁的四个必要条件 　　　1.互斥性：线程对资源的占有是排他性的，一个资源只能被一个线程占有，直到释放。 　　　2.请求和保持条件：一个线程对请求被占有资源发生阻塞时，对已经获得的资源不释放。 　　　3.不剥夺：一个线程在释放资源之前，其他的线程无法剥夺占用。 　　　...
java多线程的死锁问题
05-20
死锁是指两个或以上的线程在互相等待对方释放资源或锁的情况下陷入了无限阻塞的状态。Java中的多线程死锁问题通常是由于多个线程试图获取同一个锁的时候，出现了循环等待的情况。解决Java多线程死锁问题的方法有以下几种： 1. 避免嵌套锁，即在持有一个锁的时候，尽量避免再去请求另一个锁； 2. 尽量保证获取锁的顺序一致，避免不同线程之间出现获取锁的顺序不一致的情况； 3. 设置超时时间，当一个线程等待一个锁的时间超过一定时间后，就放弃该锁，防止出现死锁的情况； 4. 避免使用过多的同步代码块，尽量减少同步的范围，避免出现锁的竞争； 5. 使用Lock对象代替synchronized关键字实现锁竞争。 以上是几种比较常见的解决Java多线程死锁问题的方法，如果我们在编写多线程程序时注意这些细节，就可以有效避免多线程死锁问题的发生。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值