JavaEE多线程-阻塞队列

最新推荐文章于 2024-07-09 16:17:35 发布
最新推荐文章于 2024-07-09 16:17:35 发布
阅读量695 收藏
点赞数
分类专栏： JavaEE 文章标签： java-ee java 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61341342/article/details/128759650
版权

目录

一、认识阻塞队列

1.1 什么是阻塞队列？

阻塞队列：从名字可以看出，他也是队列的一种，那么他肯定是一个先进先出（FIFO）的数据结构。与普通队列不同的是，他支持两个附加操作，即阻塞添加和阻塞删除方法。

阻塞队列本质上还是一种队列, 和普通队列一样, 遵循先进先出, 后进后出的规则, 但阻塞队例相比于普通队列的特殊之处在于阻塞队列的阻塞功能, 主要基于多线程使用.

1.如果队列为空, 执行出队列操作, 就会使线程陷入阻塞, 阻塞到另一个线程往队列里添加元素(队列不空)为止.
2.如果队列满了，执行入队列操作, 也会使线程阻塞, 阻塞到另一个线程从队列取走元素位置(队列不满)为止.

1.2 生产者消费者模型

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式，都会找一个第三者出来进行解耦，如工厂模式的第三者是工厂类，模板模式的第三者是模板类。在学习一些设计模式的过程中，如果先找到这个模式的第三者，能帮助我们快速熟悉一个设计模式。

在这里插入图片描述
生产者消费者模型能够给程序带来两个非常重要的好处, 一是可以实现实现了发送方和接收方之间的 “解耦” , 二是可以 “削峰填谷” , 保证系统的稳定性, 具体理解如下:

1.3 标准库中的阻塞队列类

Java标准库也提供了阻塞队列的标准类, 常用的有下面几个：

  • ArrayBlockingQueue : 基于数组实现界阻塞队列
  • LinkedBlockingQueue : 基于链表实现的有界阻塞队列
  • PriorityBlockingQueue : 带有优先级(堆)的无界阻塞队列
  • BlockingQueue接口 : 上面的类实现了该接口

  • 根据插入和取出两种类型的操作，具体分为下面一些类型：
    在这里插入图片描述

  • 抛出异常是指当队列满时，再次插入会抛出异常（如果队列未满，插入返回值未true）；
  • 返回布尔是指当队列满时，再次插入会返回false；
  • 阻塞是指当队列满时，再次插入会被阻塞，直到队列取出一个元素，才能插入。
  • 超时是指当一个时限过后，才会插入或者取出。 
  • public class Test {
    public static void main(String[] args) {
        BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>();
        //消费者线程
        Thread customer = new Thread(() -> {
           while (true) {
               try {
                   Integer result = blockingQueue.take();
                   System.out.println("消费元素: " + result);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        customer.start();

        //生产者线程
        Thread producer = new Thread(() -> {
            int count = 0;
            while (true) {
                try {
                    blockingQueue.put(count);
                    System.out.println("生产元素: " + count);
                    count++;
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        producer.start();
    }
}

    二、循环队列实现简单阻塞队列

    2.1 实现循环队列

    //普通的循环队列
class MyBlockingQueue {
    //存放元素的数数组
    private int[] items = new int[1000];
    //队头指针
    private int head = 0;
    //队尾指针
    private int tail = 0;
    //记录队列元素的个数
    private int size = 0;

    //入队操作
    public void put (int val) {
        if (size == items.length) {
            //队列满了
            return;
        }
        items[tail++] = val;
        //等价于 tail %= items.length
        if (tail >= items.length) {
            tail = 0;
        }
        size++;
    }

    //出队操作
    public Integer take() {
        int resulet = 0;
        if (size == 0) {
            //队列空了
            return null;
        }
        resulet = items[head++];
        //等价于 head %= elem.length
        if (head >= items.length) {
            head = 0;
        }
        size--;
        return resulet;
    }
}

    2.2 阻塞队列实现

    考虑线程安全问题，循环队列中的take和put方法都有写操作，直接加锁即可。

    //线程安全的循环队列
class MyBlockingQueue {
    //存放元素的数数组
    private int[] items = new int[1000];
    //队头指针
    private int head = 0;
    //队尾指针
    private int tail = 0;
    //记录队列元素的个数
    private int size = 0;

    //入队操作
    public void put (int val) {
        synchronized (this) {
            if (size == items.length) {
                //队列满了
                return;
            }
            items[tail++] = val;
            //等价于 tail %= items.length
            if (tail >= items.length) {
                tail = 0;
            }
            size++;
        }
    }

    //出队操作
    public Integer take() {
        int resulet = 0;
        synchronized (this) {
            if (size == 0) {
                //队列空了
                return null;
            }
            resulet = items[head++];
            //等价于 head %= elem.length
            if (head >= items.length) {
                head = 0;
            }
            size--;
            return resulet;
        }
    }
}

    实现阻塞效果，主要使用wait和notify实现线程的阻塞等待
    入队时, 队列满了需要使用wait方法使线程阻塞, 直到有元素出队队列不满了再使用notify通知线程执行.
    出队时, 队列为空也需要使用wait方法使线程阻塞, 直到有新元素入队再使用notify通知线程执行.

    class MyBlockingQueue {
    //存放元素的数数组
    private int[] items = new int[1000];
    //队头指针
    private int head = 0;
    //队尾指针
    private int tail = 0;
    //记录队列元素的个数
    private int size = 0;

    //入队操作
    public void put (int val) throws InterruptedException {
        synchronized (this) {
            if (size == items.length) {
                //队列满了,阻塞等待
                this.wait();
            }
            items[tail++] = val;
            //等价于 tail %= items.length
            if (tail >= items.length) {
                tail = 0;
            }
            size++;
            //唤醒因队列空造成的阻塞wait
            this.notify();
        }
    }

    //出队操作
    public Integer take() throws InterruptedException {
        int resulet = 0;
        synchronized (this) {
            if (size == 0) {
                //队列空了,阻塞等待
                this.wait();
            }
            resulet = items[head++];
            //等价于 head %= elem.length
            if (head >= items.length) {
                head = 0;
            }
            size--;
            //唤醒因队列满造成的阻塞wait
            this.notify();
            return resulet;
        }
    }
}

    思考：当代码中当wait被唤醒的时候，此时的if条件一定就不成立了吗？

    为了稳妥起见，最好的办法就是wait唤醒之后再判断一下条件是否满足。

    //出队部分
while (size == items.length) {
    //队列满了,阻塞等待
    this.wait();
}

//入队部分
while (size == 0) {
    //队列空了,阻塞等待
    this.wait();
}

    我们创建两个线程分别是消费者线程customer和生产者线程producer, 生产者生产数字, 消费者消费数字, 为了让执行结果中的阻塞效果明显一些, 我们可以使用sleep方法来控制一下生产者/消费者的生产/消费的频率, 这里我们让开始时生产的速度快一些, 消费的速度慢一些。

    class MyBlockingQueue {
    //存放元素的数数组
    private int[] items = new int[1000];
    //队头指针
    private int head = 0;
    //队尾指针
    private int tail = 0;
    //记录队列元素的个数
    private int size = 0;

    //入队操作
    public void put (int val) throws InterruptedException {
        synchronized (this) {
            while (size == items.length) {
                //队列满了,阻塞等待
                this.wait();
            }
            items[tail++] = val;
            //等价于 tail %= items.length
            if (tail >= items.length) {
                tail = 0;
            }
            size++;
            //唤醒因队列空造成的阻塞wait
            this.notify();
        }
    }

    //出队操作
    public Integer take() throws InterruptedException {
        int resulet = 0;
        synchronized (this) {
            while (size == 0) {
                //队列空了,阻塞等待
                this.wait();
            }
            resulet = items[head++];
            //等价于 head %= elem.length
            while (head >= items.length) {
                head = 0;
            }
            size--;
            //唤醒因队列满造成的阻塞wait
            this.notify();
            return resulet;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //消费线程
        MyBlockingQueue queue = new MyBlockingQueue();
        Thread customer = new Thread(() -> {
            while(true) {
                try {
                    int result = queue.take();
                    System.out.println("消费元素: " + result);
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        customer.start();
        //生产线程
        Thread producer = new Thread(() -> {
            int count = 0;
            while (true) {
                try {
                    queue.put(count);
                    System.out.println("生产元素: " + count);
                    count++;
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        producer.start();
    }
}
摸鱼王胖嘟嘟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
javaee-api-8.0-javadoc.jar
10-12
javaee-api-8.0-javadoc.jar，这是javaee1.8api的jar包，解压后可用javadoc2chm制作成chm帮助文档。
javaee-api-7.0.jar
05-22
javaweb/javaEE常用jar包，亲测可用，导入到java工程中使用
JavaEE-多线程-阻塞队列
Gremmie的博客
08-05 208
本文主要介绍了多线程中的阻塞队列,并且简单介绍了生产者消费者模型
多线程--阻塞队列
qq_48584557的博客
03-29 367
阻塞队列及实现，消费者生产者模型
【JavaEE】多线程案例-阻塞队列
不能再留遗憾了的博客
09-15 1030
多线程案例-阻塞队列，什么是生产者-消费者模型，什么是阻塞队列，如何使用Java标准库提供的阻塞队列，如何自己实现一个阻塞队列
JavaEE--阻塞队列
weixin_73491661的博客
05-21 434
volatile 不仅仅能解决内存可见性问题，也能禁止针对这个变量读写操作的指令重排序问题面试时让写一个单例模式的代码1:先写最初的版本（不考虑线程安全问题）2:加上锁3：加上双重 if4:加上 volatile。
JAVAEE多线程 ---- 三
m0_47265327的博客
03-26 76
JavaEE之多线程初
JAVAEE-7-阻塞队列
m0_73700505的博客
12-04 220
阻塞队列是基于普通队列做出的扩展(先进先出)
JavaEE初阶----多线程初阶----Thread
baiyang2001的博客
03-31 1670
JavaEE初阶--有关多线程入门的一些知识点
JavaEE多线程-线程池
摸鱼胖嘟嘟的博客
03-25 299
随着并发程度的提高, 当我们去频繁的创建和销毁线程, 此时程序的开销还是挺大的, 为了进一步提高效率, 就引入了线程池, 程序中所创建的线程都会加载到一个 “池子” 中, 当程序需要使用线程的时候, 可以直接从池里面获取, 用完了就将线程还给池, 这样在多线程的环境中就不用去重复的创建和销毁线程, 从而使程序的运行效率提高, 线程池是管理线程的方式之一.线程池和和字符串常量池, 数据库连接池一样, 都是为了提高程序的运行效率, 减少开销。使用线程池时, 往往使用的是。
【JavaEE】多线程之阻塞队列（BlockingQueue）
努力
03-27 735
阻塞队列的简单应用和模拟实现
JavaEE-8.0-api.zip
12-09
JavaEE（Java Platform, Enterprise Edition）是Oracle公司提供的一个企业级应用开发平台，它为构建分布式、基于组件的Web应用程序提供了全面的框架和服务。JavaEE 8.0是该平台的一个重要版本，它引入了许多新特性和...
javaee-api-7.0-sources.jar
08-01
javaee-api-7.0.jar的.Java文件，分享给想看源码的同学。同事该包能解决myeclipse中的"the source attachment does not contain the source for the file xxx.class"问题
Javaee --- 学生成绩管理系统
12-09
这个系统利用了JavaEE的多层次架构，包括前端展示层、业务逻辑处理层以及数据访问层，以实现高效、安全的数据存储和交互。 **JavaEE技术栈** JavaEE（Java Enterprise Edition）是Java平台上用于构建企业级应用的...
JavaEE——计算机工作原理
Yuan_o_的博客
07-05 922
现代计算机，大多遵守冯诺依曼体系结构CPU中央处理器：进行算术运算与逻辑判断存储器：分为外存和内存，用于存储数据（使用二进制存储）输入设备：用户给计算机发号施令的设备输出设备：计算机给用户汇报结果的设备针对存储空间：硬盘 > 内存 >> CPU针对数据访问速度：CPU >> 内存 > 硬盘。
java Object 转 Integer
最新发布
servepeople的博客
07-09 214
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 991
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 672
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
必须声明元素 javaee:handler-chains
06-03
好的，你的第一个问题是关于声明元素 javaee:handler-chains 的。我理解你想了解如何声明该元素。在 Java EE 中，可以使用 javaee:handler-chains 元素来定义处理程序链。处理程序链是一系列处理程序，用于处理 Web ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

摸鱼王胖嘟嘟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值