java线程的死锁和交互

最新推荐文章于 2024-07-14 22:18:32 发布
最新推荐文章于 2024-07-14 22:18:32 发布
阅读量198 收藏
点赞数
分类专栏： java中级 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45905045/article/details/125117332
版权

1JAVA 演示多线程死锁：

演示死锁

1. 线程1 首先占有对象1，接着试图占有对象2
2. 线程2 首先占有对象2，接着试图占有对象1
3. 线程1 等待线程2释放对象2
4. 与此同时，线程2等待线程1释放对象1

线程代码如下：

public class Hero {
    public String name;
    public float hp;

    public int damage;

    public void attackHero(Hero h) {
        //把暂停时间去掉，多条线程各自会尽力去占有CPU资源
        //线程的优先级效果才可以看得出来
//        try {
//
//            Thread.sleep(0);
//        } catch (InterruptedException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }
        h.hp-=damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n",name,h.name,h.name,h.hp);

        if(h.isDead())
            System.out.println(h.name +"死了！");
    }

    public boolean isDead() {
        return 0>=hp?true:false;
    }
}

  public static void main(String[] args) {
        final Hero ahri = new Hero();
        ahri.name = "九尾妖狐";
        final Hero annie = new Hero();
        annie.name = "安妮";

        Thread t1 = new Thread(){
            public void run(){
                //占有九尾妖狐
                synchronized (ahri) {
                    System.out.println("t1 已占有九尾妖狐");
                    try {
                        //停顿1000毫秒，另一个线程有足够的时间占有安妮
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                    System.out.println("t1 试图占有安妮");
                    System.out.println("t1 等待中 。。。。");
                    synchronized (annie) {
                        System.out.println("do something");
                    }
                }

            }
        };
        t1.start();
        Thread t2 = new Thread(){
            public void run(){
                //占有安妮
                synchronized (annie) {
                    System.out.println("t2 已占有安妮");
                    try {

                        //停顿1000毫秒，另一个线程有足够的时间占有暂用九尾妖狐
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("t2 试图占有九尾妖狐");
                    System.out.println("t2 等待中 。。。。");
                    synchronized (ahri) {
                        System.out.println("do something");
                    }
                }

            }
        };
        t2.start();
    }

练习-死锁 

3个同步对象a, b, c
3个线程 t1,t2,t3
故意设计场景，使这3个线程彼此死锁

 public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
 
        Thread t1 =new Thread(){
            public void run(){
                synchronized (a) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    synchronized (b) {
                        synchronized (c) {
                             
                        }
                    }
                }  
            }
        };
        Thread t2 =new Thread(){
            public void run(){
                synchronized (c) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    synchronized (a) {
                        synchronized (b) {
                             
                        }
                    }
                }  
            }
        };
        Thread t3 =new Thread(){
            public void run(){
                synchronized (b) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    synchronized (c) {
                        synchronized (a) {
                             
                        }
                    }
                }  
            }
        };
 
        t1.start();
        t2.start();
        t3.start();
        
   }

2JAVA 线程之间的交互 WAIT和NOTIFY

线程之间有交互通知的需求，考虑如下情况：
有两个线程，处理同一个英雄。
一个加血，一个减血。
减血的线程，发现血量=1，就停止减血，直到加血的线程为英雄加了血，才可以继续减血

1不好的解决方式：

故意设计减血线程频率更高，盖伦的血量迟早会到达1
减血线程中使用while循环判断是否是1，如果是1就不停的循环,直到加血线程回复了血量
这是不好的解决方式，因为会大量占用CPU,拖慢性能

/**
 * java线程之间的交互
 */
public class Hero {
    public String name;
    public float hp;

    public int damage;

    public synchronized  void recover(){
        hp=hp+1;
    }
    public synchronized void hurt(){
        hp=hp-1;
    }

    public void attackHero(Hero h) {
        h.hp-=damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n",name,h.name,h.name,h.hp);
        if(h.isDead())
            System.out.println(h.name +"死了！");
    }

    public boolean isDead() {
        return 0>=hp?true:false;
    }
}

 public static void main(String[] args) {

        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;

        Thread t1 = new Thread(){
            public void run(){
                while(true){

                    //因为减血更快，所以盖伦的血量迟早会到达1
                    //使用while循环判断是否是1，如果是1就不停的循环
                    //直到加血线程回复了血量
                    while(gareen.hp==1){
                        continue;
                    }

                    gareen.hurt();
                    System.out.printf("t1 为%s 减血1点,减少血后，%s的血量是%.0f%n",gareen.name,gareen.name,gareen.hp);
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

            }
        };
        t1.start();

        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    gareen.recover();
                    System.out.printf("t2 为%s 回血1点,增加血后，%s的血量是%.0f%n",gareen.name,gareen.name,gareen.hp);

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

            }
        };
        t2.start();

    }

2使用wait和notify进行线程交互：

在Hero类中：hurt()减血方法：当hp=1的时候，执行this.wait().
this.wait()表示 让占有this的线程等待，并临时释放占有
进入hurt方法的线程必然是减血线程，this.wait()会让减血线程临时释放对this的占有。 这样加血线程，就有机会进入recover()加血方法了。
recover() 加血方法：增加了血量，执行this.notify();
this.notify() 表示通知那些等待在this的线程，可以苏醒过来了。 等待在this的线程，恰恰就是减血线程。 一旦recover()结束， 加血线程释放了this，减血线程，就可以重新占有this，并执行后面的减血工作。

代码如下：

public class Hero {
    public String name;
    public float hp;
 
    public int damage;
 
    public synchronized void recover() {
        hp = hp + 1;
        System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
        // 通知那些等待在this对象上的线程，可以醒过来了，如第20行，等待着的减血线程，苏醒过来
        this.notify();
    }
 
    public synchronized void hurt() {
        if (hp == 1) {
            try {
                // 让占有this的减血线程，暂时释放对this的占有，并等待
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
 
        hp = hp - 1;
        System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);
    }
 
    public void attackHero(Hero h) {
        h.hp -= damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n", name, h.name, h.name, h.hp);
        if (h.isDead())
            System.out.println(h.name + "死了！");
    }
 
    public boolean isDead() {
        return 0 >= hp ? true : false;
    }
 
}
 public static void main(String[] args) {
    
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
             
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                       
                    //无需循环判断
//                    while(gareen.hp==1){
//                        continue;
//                    }
                       
                    gareen.hurt();
                     
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
   
            }
        };
        t1.start();
   
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    gareen.recover();
   
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
   
            }
        };
        t2.start();
             
    }

留意wait()和notify() 这两个方法是什么对象上的？

这里需要强调的是，wait方法和notify方法，并不是Thread线程上的方法，它们是Object上的方法。
因为所有的Object都可以被用来作为同步对象，所以准确的讲，wait和notify是同步对象上的方法。
wait()的意思是： 让占用了这个同步对象的线程，临时释放当前的占用，并且等待。 所以调用wait是有前提条件的，一定是在synchronized块里，否则就会出错。
notify() 的意思是，通知一个等待在这个同步对象上的线程，你可以苏醒过来了，有机会重新占用当前对象了。
notifyAll() 的意思是，通知所有的等待在这个同步对象上的线程，你们可以苏醒过来了，有机会重新占用当前对象了。

练习-线程交互 ：

假设加血线程运行得更加频繁，英雄的最大血量是1000
设计加血线程和减血线程的交互，让回血回满之后，加血线程等待，直到有减血线程减血

public class Hero {
    public String name;
    public float hp;
  
    public int damage;
  
    public synchronized void recover() {
        //当血量大于或者等于1000的时候
        //this.wait() 让占用这个对象的线程等待，并临时释放锁
        if(hp>=1000){
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
         
        hp = hp + 1;
        System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
        this.notify();
    }
  
    public synchronized void hurt() {
        if (hp == 1) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
  
        hp = hp - 1;
        System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);
        //掉血之后，唤醒等待的线程
        this.notify();
    }
  
    public void attackHero(Hero h) {
        h.hp -= damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n", name, h.name, h.name, h.hp);
        if (h.isDead())
            System.out.println(h.name + "死了！");
    }
  
    public boolean isDead() {
        return 0 >= hp ? true : false;
    }
  
public static void main(String[] args) {
     
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
              
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                    gareen.hurt();
                      
                    try {
                        //减慢掉血的速度
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
    
            }
        };
        t1.start();
    
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    gareen.recover();
    
                    try {
                        //加快回血的速度
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
    
            }
        };
        t2.start();
              
    }

在上面的练习的基础上，增加回血线程到2条，减血线程到5条，同时运行。
运行一段时间，观察会发生的错误，分析错误原因，并考虑解决办法


//把if改为while，被唤醒后，会重复查看hp的值，只有hp大于1，才会往下执行

//把if改为while，被唤醒后，会重复查看hp的值，只有hp大于1，才会往下执行

//if(hp <= 1) {

while (hp <= 1) {

try {

this.wait();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

姜大师在线求学
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现线程死锁
ys_xixihaha的博客
02-17 91
public class DeadLock1 { public static void main(String[] args) { Object o1 = new Object(); Object o2 = new Object(); // t1和t2两个线程共享o1,o2 MyThread1 m1 = new MyThread1(o1,o2); MyThread2 m2 = new MyThread2(o1,o2);
Java线程的并发及并行
JSDHBIV的博客
07-19 897
并发与并行并发与并行的区别并发概念临界资源和临界区什么是线程安全？并发的特性原子性可见性有序性 并发与并行的区别 并发是指多个线程操作同一个资源，不是同时执行，而是交替执行。单核CPU，只不过因为CPU的时间片很短，速度太快，看起来是同时执行。 并行才是真正的同时执行，多核CPU。每个线程使用一个单独的CPU的资源来运行。 并发示意图： 并行示意图： 但在多数情况下，我们的即使有多核，也同样存在并行的情况，且存在并行与并发同时存在的情况。 并发概念 Java并发的重要性毋庸置疑，可以最大化的提高计算资源
java 关于wait，notify和notifyAll
YZ930035683的博客
09-08 111
public synchronized void hurt() { //... this.wait(); //... } public synchronized void recover() { //... this.notify(); } 这里需要强调的是，wait方法和notify方法，并不是Thread线程上的方法，它们是O...
java学习笔记 多线程（二）线程同步、死锁、交互
云乐
12-02 289
线程同步问题： 假设有一个数x=1000,有两个线程，一个给x加一操作、另一个给x减一操作， 那么在执行n次之后，讲道理x应该还是等于1000的，但是因为线程同步的问题，最后会出现x!=1000的情况。 线程同步问题产生的原因： 1. 假设增加线程先进入，得到的x是1000 2. 进行增加运算 3. 正在做增加运算的时候，还没有来得及修改hp的值，减少线程来了 4. 减少线程得到的h...
java--线程--习题集锦
weixin_30832983的博客
05-05 742
匿名类的一个好处是可以很方便的访问外部的局部变量。 前提是外部的局部变量需要被声明为final。(JDK7以后就不需要了) ====================== 同步方法1：普通式 同步方法2：在对象方法里 写关键字,用this 同步方法3：在方法前，加上修饰符synchronized，效果等同方法2 ================== 题目1--同步查找文件内容 把 练习-查找...
java-多线程
xiaoguxin的博客
08-22 639
多线程 先看个思维导图呗 启动一个线程 多线程即在同一时间，可以做多件事情。 创建多线程有3种方式，分别是继承线程类,实现Runnable接口,匿名类。 1.线程概念 首先要理解进程(Processor)和线程(Thread)的区别 进程：启动一个LOL.exe就叫一个进程。 接着又启动一个DOTA.exe，这叫两个进程。 线程：线程是在进程内部同时做的事情，比如在LOL里，有很多事情要同时...
JAVA 线程之间的交互 wait和notify
litengbin的博客
01-09 1200
线程之间有交互通知的需求，考虑如下情况：  有两个线程，处理同一个英雄。  一个加血，一个减血。  减血的线程，发现血量=1，就停止减血，直到加血的线程为英雄加了血，才可以继续减血 不好的解决方式 故意设计减血线程频率更高，盖伦的血量迟早会到达1 减血线程中使用while循环判断是否是1，如果是1就不停的循环,直到加血线程回复了血量 这是不好的解决方式，因为会大量占用CPU,
java模拟线程死锁
01-28
Java 模拟线程死锁 线程死锁 在 Java 中，线程死锁（Deadlock）是一种特殊的情况，发生...为了避免线程死锁，我们需要在设计线程之间的交互时，遵循一定的规则和原则，例如避免循环等待、使用锁对象和线程通信机制。
java线程分析工具TDA
06-21
Java线程分析是Java开发中的重要环节，尤其是在处理性能优化、死锁排查或者并发问题时。TDA（Thread Dump Analyzer）是一款强大的Java线程分析工具，它能够帮助开发者深入理解应用在运行时的线程状态，包括线程的...
Java多线程程序死锁检查类库 JCarder
05-14
为了解决这个问题，开发者可以利用特定的工具进行检测，而JCarder就是这样一款用于Java多线程死锁检测的类库。 JCarder的设计目标是帮助Java程序员在运行时分析和检测潜在的死锁现象。它提供了一种动态监测机制，...
Java多线程编程的优点和缺点
10-16
5. **调试困难**：由于线程间的并发执行，问题可能出现在多个线程的交互过程中，这使得调试变得复杂和困难。 6. **资源竞争**：多线程可能会引起对计算机资源的激烈竞争，如果不妥善管理，可能会导致资源耗尽或性能...
14个Java线程并发面试题和答案..pdf
12-01
Java线程并发是一种复杂的技术，需要深入理解线程之间的交互、同步机制、死锁、饥饿、活锁等概念。以下是14个Java线程并发面试题和答案的详细解析： 1. 问题：java中的线程是什么？ 答案：在Java中，线程是指一个...
how2J学习之Java多线程
inf_zh
01-15 483
多线程即在同一时间，可以做多件事情。 创建多线程有3种方式，分别是继承线程类，实现Runnable接口，匿名类。 首先看看不使用多线程的情况： package charactor; import java.io.Serializable; public class Hero{ public String name; public float hp; p...
java学习----递归
qq_56798493的博客
07-13 152
【代码】java学习----递归。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
最新发布
m0_73456341的博客
07-14 780
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 620
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 857
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 986
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java 线程池详解
qq_41591215的博客
07-13 936
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
Java多线程同步与死锁实例分析
Java IO（Input/Output）模块负责与外部数据源和设备进行交互，JDBC（Java Database Connectivity）则用于数据库连接和操作。 学习Java SE技术时，除了掌握基础知识，还需要培养查找文档、解决问题的能力，并提倡...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值