JavaEE 第7节 线程饥饿及其解决办法

已于 2024-08-27 18:45:21 修改
阅读量905 收藏 24
点赞数 21
分类专栏： JavaEE基础 # JAVA EE 多线程 文章标签： java 开发语言
于 2024-08-08 16:37:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80636143/article/details/140618171
版权

目录

一、什么是线程饥饿？

二、线程饥饿的解决办法

*wait()与notify()方法解决线程饥饿

1、wait(等待)

2、notify(通知)

1）notify

2）notifyAll

3）关于wait方法的一些补充

1、wait的方法的三个功能是原子性的：

2、sleep与wait方法的异同

相同点：

不同点：

        所属类：

        锁释放：

        使用场景：

        调用位置：

一、什么是线程饥饿？

线程饥饿（Thread Starvation）指的是多线程中，某些线程无法获得相关资源或者执行机会（阻塞，BLOCKED），长时间如此对线程的推进和响应造成明显影响的现象：

左边的蘑菇头和右边的小人都是线程，左边的蘑菇头因为在所中没有自己想要的资源所以从锁中出来，但是由于它的优先级比较高，一从锁里出来，转头有跑进锁里面了，完全没有给右边的小进去的机会。

当饥饿到一定程度，赋予线程的任务即使完成也不在具有实际意义的时候，就说明这个线程被饿死了。

二、线程饥饿的解决办法

线程饥饿原因：

线程产生饥饿，主要是因为系统对线程调度方式不够公平或者不合理导致的。

想要解决饥饿问题，我们只需要通过一些手段，对线程的调度进行合理的干预即可。

比如上图中的蘑菇头线程，如果自己目前拿不到想要的资源结果，那就先把锁让给别的线程，不要自己在锁这里反复横跳！等别的线程把资源变量改成蘑菇头想要的结果的时候，然后再让蘑菇头进来拿锁。

*wait()与notify()方法解决线程饥饿

这两个方法可以让多个线程按照某一个逻辑上的先后顺序执行，从而避免线程的饿死。

注意：两个方法都必须使用锁对象调用！

1、wait(等待)

wait()方法有三个功能：

1）让当前线程释放持有的锁。

2）让当前线程进入WAITING状态（或者TIMED_WAITING，取决于括号中是否含有时间参数，ms）。

3）检测其他线程是否调用了同对象的notify()方法，如果调用了notify()方法，那么唤醒正在睡眠的线程。

注释：

这三个功能都已经集成到的wait方法上，且是原子性的！(最后一个小节讲解原因)

使用方式：

public class Threads {

    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
       Thread thread1=new Thread(()->{
          synchronized (lock){
              try {
                  lock.wait();//进入等待状态（WAITING），必须用lock调用
              } catch (InterruptedException e) {//与sleep方法类似，需要try catch，
                  // 但是wait不能自动唤醒自己，只能考notify方法

                  e.printStackTrace();
              }
          }
       });
       thread1.start();
       thread1.join();
    }
}

上面这个程序会造成程序的卡死。

原因：

wait()没有时间参数，那么就必须等其他线程用notify()方法唤醒它，但是我没有写notify方法，所以thread1会一直处在WAITINGZ状态，但是主线程有用了join()方法，所以主线程一直在等thread1线程运行完毕，进而造成程序的卡死，注意这不是死锁！

如果不想死等，那么可以使用带时间参数的重载方法：

public class Threads {

    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
       Thread thread1=new Thread(()->{
          synchronized (lock){
              try {
                  lock.wait(1000);//带参数，1秒
              } catch (InterruptedException e) {//与sleep方法类似，需要try catch
                  e.printStackTrace();
              }
          }
       });
       thread1.start();
       thread1.join();
    }
}

2、notify(通知)

1）notify

我们刚才看到了，仅仅用wait方法是不够的，需要与notify方法搭配。

notify方法可以把因为wait而睡眠的线程唤醒：

public class Threads {

    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
       Thread thread1=new Thread(()->{
          synchronized (lock){
              try {

                  System.out.println("thread1即将进入睡眠，等待其他线程用notify方法唤醒");
                  lock.wait();
                  System.out.println("thread1成功被唤醒");
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
       });
       Thread thread2=new Thread(()->{
          synchronized (lock){
              try {
                  Thread.sleep(1000);//确保thread1线程先执行，不然唤醒个寂寞
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println("thread2即将使用norify方法唤醒thread1");
              lock.notify();//同样，必须用lock调用！！
              System.out.println("thread2已唤醒thread1");
          }
       });


       thread1.start();
       thread2.start();
       thread1.join();
       thread2.join();
    }
}

执行结果：

倘若同时有多个线程调用wait方法，那么notify方法会"随机"的唤醒一个线程（具体由操作系统决定）：

public class Threads {

    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {

                    System.out.println("thread1即将进入睡眠，等待其他线程用notify方法唤醒");
                    lock.wait();
                    System.out.println("thread1成功被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                try {

                    System.out.println("thread2即将进入睡眠，等待其他线程用notify方法唤醒");
                    lock.wait();
                    System.out.println("thread2成功被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread3 = new Thread(() -> {
            synchronized (lock) {
                try {

                    System.out.println("thread3即将进入睡眠，等待其他线程用notify方法唤醒");
                    lock.wait();
                    System.out.println("thread3成功被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread4 = new Thread(() -> {
            synchronized (lock) {
                try {
                    Thread.sleep(1000);//确保thread1线程先执行，不然唤醒个寂寞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread4即将使用norify方法唤醒thread1");
                lock.notify();
                System.out.println("thread2已唤醒thread1");
            }
        });


        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread1.join();
        thread2.join();
        thread3.join();
        thread4.join();
    }
}

执行结果只会唤醒一个线程：

注意：

多次notify不会有副作用，即使没有线程wait过：

public class Threads {

    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
    Thread t1=new Thread(()->{
        synchronized (lock){
            lock.notify();
            lock.notify();
            lock.notify();
            lock.notify();
            lock.notify();
            lock.notify();
            lock.notify();
            lock.notify();
            lock.notify();
        }
    });
    t1.start();
    t1.join();
    }
}

当然不建议这样做，谁会这么无聊🤪

2）notifyAll

如果想要全部唤醒，也有办法，那就是使用notifyAll方法：

public class Threads {

    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {

                    System.out.println("thread1即将进入睡眠，等待其他线程用notify方法唤醒");
                    lock.wait();
                    System.out.println("thread1成功被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                try {

                    System.out.println("thread2即将进入睡眠，等待其他线程用notify方法唤醒");
                    lock.wait();
                    System.out.println("thread2成功被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread3 = new Thread(() -> {
            synchronized (lock) {
                try {

                    System.out.println("thread3即将进入睡眠，等待其他线程用notify方法唤醒");
                    lock.wait();
                    System.out.println("thread3成功被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread4 = new Thread(() -> {

            
                try {
                    Thread.sleep(1000);//确保其他线程先执行，不然唤醒个寂寞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                    synchronized (lock){
                        System.out.println("即将唤醒所有线程");
                        lock.notifyAll();/**换成notifyAll方法，其他代码都没有变*/
                        System.out.println("thread2已唤醒所有线程");
                    }

        });

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread1.join();
        thread2.join();
        thread3.join();
        thread4.join();
    }
}

其中一个执行结果：

注意：

1）由于thread1、thread2、thread3是同时被唤醒的。之后这3个线程会进入锁竞争只有一个线程可以拿到锁然后执行，因此thread1、thread2、thread3三个线程那个先执行完是不确定的。

2）notify方法不像wait方法，wait方法调用的时候会释放当前对象的锁，但是notify方法没有这样的功能！！！也就是说，只有调用notify的线程释放了锁，被notify唤醒的线程才有机会执行。（notifyAll与notify是一样的）

3）关于wait方法的一些补充

1、wait的方法的三个功能是原子性的：

1）让当前线程释放持有的锁。

2）让当前线程进入WAITING状态（或者TIMED_WAITING，取决于括号中是否含有时间参数，ms）。

3）检测其他线程是否调用了同对象的notify()方法，如果调用了notify()方法，那么唤醒正在睡眠的线程。（InterruptedException也会提前唤醒wait过的线程）

假设不满足原子性：

有t1和t2两个线程，t1线程调用wait方法，要等待t2线程用notify唤醒t1。

若t1在执行完第一个功能后，由于线程调度的原因，t1在没有进入睡眠的状态就提前释放了锁，给t2，那么会出现这个情况：

t2线程提前执行了notify方法，t2线程运行完后，锁就交给了t1，紧接着t1就开始进入睡眠状态，等待t2线程用notify唤醒t1？这显然不符合逻辑。

2、sleep与wait方法的异同

相同点：

1）都可以暂停线程执行（这里说的暂停指的是当前线程不做任何任务，或者说任务就是睡觉）

2）都会抛出InterruptedException，需要对异常进行处理

注意：

调用了wait方法的线程如果捕获到InterruptedException，此线程就会终止。

不同点：
        所属类：

                1）sleep是Thread类的静态方法。

                2）wait是Object类的示例方法，且必须由锁对象调用。

        锁释放：

                1）sleep睡眠不会释放锁，也就是抱着锁睡：

                2）wait会释放锁，然后再睡。

        使用场景：

                1）sleep用于暂停线程执行一段时间，用的比较广泛。

                2）wait一般用在线程之间的通信，等待某个条件成立，接收notify信号。

        调用位置：

                1）sleep可以在任意地方调用。

                2）wait必须在同步块中调用（synchronized）。

灰阳阳
关注
专栏目录
Java面试知识点总结③——多线程和并发
dooduoaixuexi的博客
09-17 905
大纲 [x] 一、Java基础(语言、集合框架、OOP、设计模式等) [x] 二、Java高级(JavaEE、框架、服务器、工具等) [x] 三、多线程和并发 [x] 四、Java虚拟机 [x] 五、数据库(Sql、MySQL、Redis等) [x] 六、算法与数据结构 [x] 七、计算机网络 [x] 八、操作系统(OS基础、Linux等) [x] 九、其他 三、多线程和并发 0. Ja...
java 多线程饥饿现象的问题解决方法
08-30
主要介绍了java 多线程饥饿现象的问题解决方法的相关资料,需要的朋友可以参考下
Java线程饥饿
allway2的博客
01-27 2811
当连续不断拒绝线程访问资源并因此无法取得进展时，就会发生饥饿。当贪婪的线程长时间使用共享资源时，通常会发生这种情况。如果这种情况持续了很长时间，则线程没有获得足够的CPU时间或对资源的访问将无法取得足够的进展，从而导致线程不足。线程饥饿的可能原因之一是不同线程或线程组之间的线程优先级不正确。 另一个可能的原因可能是使用非终止循环（无限循环）或在特定资源上等待过多时间，同时保留了其他线程所需的关键锁。 通常建议尽量避免修改线程优先级，因为这是导致线程饥饿的主要原因。一旦开始使用线程优先级调整应用程序，它就
线程池中的饥饿问题和定时延时任务和异常处理
qq_53318060的博客
03-26 371
线程池中的饥饿问题和定时延时任务和异常处理
22.线程的活性故障:线程饥饿
一枝会思想的芦苇的博客
02-26 648
线程饥饿是指线程一直无法获得其所需的资源而导致其任务一直无法进展的一种活性故障。线程饥饿涉及的线程，其生命周期状态不一定就是 WATING 或者 BLOCKED 状态，其状态也可能是 RUNNING (这说明涉及的线程一直在申请其所需的资源），这时饥饿就演变成活锁。 ...
线程饥饿死锁
弹指天下
04-10 7425
线程饥饿死锁：       在一个线程池中，如果一个任务依赖于其他任务的执行，就可能产生死锁。对应一个单线程话的Executor,一个任务将另一个任务提交到相同的Executor中，并等待新提交的任务的结果，这总会引发死锁。第二个任务滞留在工作队列中，直到第一个任务完成，但是第一个任务不会完成，因为它在等待第二个任务的完成。        同样在一个大的线程池中，如果所有线程执行的任务
Javaee第7章源代码
06-22
JavaEE，全称为Java Platform, Enterprise Edition，是Java平台针对企业级应用开发的...通过研究这些代码，开发者可以更好地理解如何在实际项目中应用JavaEE 7的各项功能，从而提高自己的编程能力和解决问题的能力。
JavaEE基础教程 多线程PPT教案学习.pptx
09-30
JavaEE基础教程多线程PPT教案学习 本资源提供了多线程编程的基础知识，涵盖了进程和线程的概念、线程的创建、线程的生命周期等内容。下面是从该资源中提取的知识点： 1. 进程的概念：进程是程序的一次执行过程，...
JavaEE 第7次
04-07
还在为找不到实验报告而发愁么，赶快来看看吧，虽然不是很好，一点借鉴意义还是有的哦！
2020新版idea创建项目没有javaEE 没有Web选项的完美解决方法
09-08
总结一下，解决2020新版Idea创建项目没有Java EE和Web选项的方法主要有以下几步： 1. 检查并安装缺失的Java EE和Web插件。 2. 使用“New Project”创建项目，选择“Java”。 3. 在项目配置界面手动添加Web支持。 4....
javaee7api.zip
02-23
"javaee7api.zip"是一个包含Java EE 7 API文档的压缩包，供开发者参考和学习使用。以下将详细介绍Java EE 7 API中的一些关键技术和知识点： 1. **Servlet 3.1**: 这个版本的Servlet规范引入了异步处理能力的增强，...
Java多线程——线程池的饥饿现象
保暖透气大裤衩LeoLee的博客
03-03 1279
概述 定长线程池的使用过程中会存在饥饿现象，也就是当多线程情况下，当池中所有线程都被占用后，被占用的线程又需要空闲线程去进行下一步的操作，此时又获取不到池中空闲的线程，此时就出现了饥饿现象。 示例 package com.leolee.multithreadProgramming.threadPool.threadHungry; import lombok.extern.slf4j.Slf4j; import java.util.Arrays; import java.util.List; im
Java并发编程学习(10):线程池、饥饿现象
weixin_43968383的博客
07-06 539
自定义线程池 class ThreadPoolTest{ public static void main(String[] args){ RejectPolicy<Runnable> rejectPolicy = BlockingQueue::put; MyThreadPool pool = new MyThreadPool(3, 1000, TimeUnit.MILLISECONDS, 4, rejectPolicy); for (int
饥饿线程
Color的博客
06-26 2424
什么是饥饿线程？ 长期没有得到运行的线程(没抢到时间片)，为什么抢不到时间片 因为线程的级别从0 -31  级别越高 执行的越高  抢占的时间片的可能就越高 导致  执行级别 保持不能运行的状态 如何避免 1  Sleep（100）  //100毫秒 并非真真实实的100毫秒而是无限接近  放弃当前线程的时间片，放弃剩余的时间片 2 SwitchToThread（）；
线程死锁、锁死、饥饿、活锁讲解
aaaPostcard的博客
12-10 1525
死锁的产生原因以及规避方法等。
线程的死锁、活锁和饥饿现象
m0_62609939的博客
03-11 2561
线程的活锁、死锁和饥饿现象
线程饥饿死锁问题排查
最新发布
Yuan_Su_的博客
07-15 116
从错误日志不能看出具有哪个线程有问题，通过线程统计线程数量看出是线程池，然后看监控发现队列确实满了。每个外层异步都会从线程池中申请一个线程执行内层异步，由于此时已经没有线程，内层异步的任务被排入任务队列中，没有执行。外层异步会在内层异步的get方法处等待，而内层异步等待外层异步完成释放线程，因此进入死锁。在某个时间范围内，线程池的所有活跃线程都去执行外部异步调用，导致可用线程数为0。效果：线程死锁解决，线程池任务队列满导致抛出的异常不再产生。使用线程隔离：内外层使用不同线程池。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值