Java Web 实战 08 - 多线程基础之阻塞队列

最新推荐文章于 2024-06-07 19:37:47 发布
最新推荐文章于 2024-06-07 19:37:47 发布
阅读量372 收藏 4
点赞数 10
分类专栏： JavaWeb 实战 文章标签： java 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53117341/article/details/129484465
版权

阻塞队列

大家好 , 这篇文章给大家讲解的知识点是 : 阻塞队列 , 我们分成几个模块来了解阻塞队列

  1. 阻塞队列是什么 ?
  2. 生产者 - 消费者模型是什么 ?
  3. 标准库当中的阻塞队列是怎样实现的 ?
  4. 自己怎样实现一个简单的阻塞队列 ?

推荐大家跳转到此链接进行观看
上一篇文章的链接也给大家贴到这里了
在这里插入图片描述

阻塞队列

1. 阻塞队列是什么 ?

这里的阻塞队列和咱们内核中 , 表示阻塞状态的 PCB 的那个链表还不一样
我们这里的阻塞队列 , 是能够保证线程安全的队列 , 内部采用了锁机制来保证线程安全
他还有一个很大的特点 : 如果队列为空 , 尝试出队列 , 就会阻塞 ; 如果队列满 , 尝试入队列 , 也会阻塞

阻塞 : 就是让线程停下来等一等 , 本质上就是修改了线程的状态 , 让线程的 PCB 在内核中暂时不参与调度

其实就相当于餐厅营业 , 没人来吃饭了咱就关门停业 ? 餐厅人多 , 咱们可以让顾客稍微等一会

相对应的还有
无锁队列 : 也是一种线程安全的队列 , 但是实现内部没有使用锁 , 相比阻塞队列来说更加高效 , 需要消耗更多的 CPU 资源
消息队列 : 在队列中涵盖多种不同 “类型” 的元素 , 取元素的时候可以按照某个类型来取 , 做到针对该类型的先进先出 , 甚至说会把消息队列作为服务器 , 单独部署 (常见的有 : kafka , rocketmq , rabbitmq)

2. 生产者-消费者模型

image.png
使用生产者消费者模型 , 在工作中是非常频繁的

生产者-消费者模型的优点有很多 , 其中最明显的优点有两条 :

  1. 可以做到更好的 “解耦合”

image.png

  1. 能够做到 “削峰填谷” , 提高整个系统的抗风险能力

image.png

那么我们刚才介绍了解耦合 , 那再帮大家回顾一下高内聚的意思
写一个功能的时候 , 尽量让这个功能的代码能够集中放置 , 不要东一块西一块
类似于 “归类”
举个栗子 :
我们要是没对自己电脑的文件进行分门别类的话 , 到时候想要找一个文件就会特别困难 .
这就是高内聚的反例
如果我们把所有的文件分门别类的存储 , 把代码放到一个文件夹 , 把软件放到另一个文件夹 , 这样就类似于 “高内聚”

3. 标准库中的阻塞队列

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Demo20 {
    public static void main(String[] args) {
        // Java 标准库中的阻塞队列
        // BlockingQueue 是父类,我们要实例化他的接口
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        // 消费者线程
        Thread customer = new Thread(() -> {
            while(true) {
                // BlockingQueue 虽然也支持 offer、poll 等普通队列的方法
                // 但是仍然推荐大家使用 put 来入队列,使用 take 来出队列(可以做到阻塞)
                try {
                    int val = queue.take();// Integer->int 自动拆箱
                    System.out.println("消费元素:" + val);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        customer.start();

        // 生产者线程
        Thread producer = new Thread(() -> {
            int n = 0;
            while(true) {
                try {
                    System.out.println("生产元素:" + n);
                    queue.put(n);
                    n++;
                    Thread.sleep(500);// 方便观察
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        producer.start();
    }
}

image.png

4. 自己实现一个阻塞队列

// 我们自己模拟一个阻塞队列
// 基于数组的方式实现阻塞队列
// 模拟两个方法:put入队列/take出队列
class MyBlockingQueue {
    // 假设阻塞队列最大是 1000 个元素
    private int[] items = new int[1000];
    // 队首
    private int head = 0;
    // 队尾
    private int tail = 0;
    // 队列的元素个数
    private int size = 0;

    // 入队列
    public void put(int value) {
        if(size == items.length) {
            // 队列已满,无法插入
            return;
        }
        items[tail++] = value;
        // 如果 tail 达到数组末尾,就需要从头开始
        if(tail == items.length) {
            tail = 0;
        }
        size++;
    }

    // 出队列
    public Integer take() {
        if(size == 0) {
            // 队列为空,无法出队列
            return null;
        }
        int ret = items[head++];
        if(size == items.length) {
            head = 0;
        }
        size--;
        return ret;
    }
}

public class Demo21 {
}

我们目前已经完成了最基本的队列的实现
接下来 , 我们就实现阻塞队列
阻塞队列需要满足两点 :

  1. 线程安全 : 通过加锁实现

image.png

// 我们自己模拟一个阻塞队列
// 基于数组的方式实现阻塞队列
// 模拟两个方法:put入队列/take出队列
class MyBlockingQueue {
    // 假设阻塞队列最大是 1000 个元素
    private int[] items = new int[1000];
    // 队首
    private int head = 0;
    // 队尾
    private int tail = 0;
    // 队列的元素个数
    private int size = 0;

    // 入队列
    public void put(int value) {
        synchronized (this) {
            if(size == items.length) {
                // 队列已满,无法插入
                return;
            }
            items[tail++] = value;
            // 如果 tail 达到数组末尾,就需要从头开始
            if(tail == items.length) {
                tail = 0;
            }
            size++;
        }
    }

    // 出队列
    public Integer take() {
        int ret = 0;
        synchronized (this) {
            if(size == 0) {
                // 队列为空,无法出队列
                return null;
            }
            ret = items[head++];
            if(size == items.length) {
                head = 0;
            }
            size--;
        }
        return ret;
    }
}

public class Demo21 {
}
  1. 阻塞 : 通过 wait() 实现
    1. 队列为空要阻塞 : 当队列不空的时候 , 就唤醒
    2. 队列未满要阻塞 : 当队列不满的时候 , 就唤醒
// 我们自己模拟一个阻塞队列
// 基于数组的方式实现阻塞队列
// 模拟两个方法:put入队列/take出队列
class MyBlockingQueue {
    // 假设阻塞队列最大是 1000 个元素
    private int[] items = new int[1000];
    // 队首
    private int head = 0;
    // 队尾
    private int tail = 0;
    // 队列的元素个数
    private int size = 0;

    // 入队列
    public void put(int value) throws InterruptedException {
        synchronized (this) {
            if(size == items.length) {
                // 队列满了,要进行阻塞
                this.wait();
            }
            items[tail++] = value;
            // 如果 tail 达到数组末尾,就需要从头开始
            if(tail == items.length) {
                tail = 0;
            }
            size++;
            // 队列不空的时候(插入元素成功),就需要唤醒
            // notify 即使没人在等待,多调用几次 notify 也没啥副作用
            this.notify();
        }
    }

    // 出队列
    public Integer take() throws InterruptedException {
        int ret = 0;
        synchronized (this) {
            if(size == 0) {
                // 队列为空,就阻塞等待
                this.wait();// wait 方法需要在 synchronized 里面使用
            }
            ret = items[head++];
            if(size == items.length) {
                head = 0;
            }
            size--;
            // 队列不满(取走一个元素),就需要唤醒
            this.notify();
        }
        return ret;
    }
}

public class Demo21 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue myQueue = new MyBlockingQueue();
        myQueue.put(100);
        myQueue.take();
    }
}

image.png

然后 , 我们还需要在每个变量前面加上 volatile 关键字 , 因为这段代码既有读 , 又有写 , 为了防止内存可见性 , 所以加上 volatile关键字

// 我们自己模拟一个阻塞队列
// 基于数组的方式实现阻塞队列
// 模拟两个方法:put入队列/take出队列
class MyBlockingQueue {
    // 假设阻塞队列最大是 1000 个元素
    volatile private int[] items = new int[1000];
    // 队首
    volatile private int head = 0;
    // 队尾
    volatile private int tail = 0;
    // 队列的元素个数
    volatile private int size = 0;

    // 入队列
    public void put(int value) throws InterruptedException {
        synchronized (this) {
            if(size == items.length) {
                // 队列满了,要进行阻塞
                this.wait();
            }
            items[tail++] = value;
            // 如果 tail 达到数组末尾,就需要从头开始
            if(tail == items.length) {
                tail = 0;
            }
            size++;
            // 队列不空的时候(插入元素成功),就需要唤醒
            // notify 即使没人在等待,多调用几次 notify 也没啥副作用
            this.notify();
        }
    }

    // 出队列
    public Integer take() throws InterruptedException {
        int ret = 0;
        synchronized (this) {
            if(size == 0) {
                // 队列为空,就阻塞等待
                this.wait();// wait 方法需要在 synchronized 里面使用
            }
            ret = items[head++];
            if(size == items.length) {
                head = 0;
            }
            size--;
            // 队列不满(取走一个元素),就需要唤醒
            this.notify();
        }
        return ret;
    }
}

public class Demo21 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue myQueue = new MyBlockingQueue();
        myQueue.put(100);
        myQueue.take();
    }
}

最后 , 我们再进行一个优化操作
image.png

// 我们自己模拟一个阻塞队列
// 基于数组的方式实现阻塞队列
// 模拟两个方法:put入队列/take出队列
class MyBlockingQueue {
    // 假设阻塞队列最大是 1000 个元素
    volatile private int[] items = new int[1000];
    // 队首
    volatile private int head = 0;
    // 队尾
    volatile private int tail = 0;
    // 队列的元素个数
    volatile private int size = 0;

    // 入队列
    public void put(int value) throws InterruptedException {
        synchronized (this) {
            while(size == items.length) {
                // 队列满了,要进行阻塞
                this.wait();
            }
            items[tail++] = value;
            // 如果 tail 达到数组末尾,就需要从头开始
            if(tail == items.length) {
                tail = 0;
            }
            size++;
            // 队列不空的时候(插入元素成功),就需要唤醒
            // notify 即使没人在等待,多调用几次 notify 也没啥副作用
            this.notify();
        }
    }

    // 出队列
    public Integer take() throws InterruptedException {
        int ret = 0;
        synchronized (this) {
            while(size == 0) {
                // 队列为空,就阻塞等待
                this.wait();// wait 方法需要在 synchronized 里面使用
            }
            ret = items[head++];
            if(size == items.length) {
                head = 0;
            }
            size--;
            // 队列不满(取走一个元素),就需要唤醒
            this.notify();
        }
        return ret;
    }
}

public class Demo21 {
    public static void main(String[] args) throws InterruptedException {
        
    }
}

接下来 , 我们就可以去模拟实现生产者-消费者模型

// 我们自己模拟一个阻塞队列
// 基于数组的方式实现阻塞队列
// 模拟两个方法:put入队列/take出队列
class MyBlockingQueue {
    // 假设阻塞队列最大是 1000 个元素
    volatile private int[] items = new int[1000];
    // 队首
    volatile private int head = 0;
    // 队尾
    volatile private int tail = 0;
    // 队列的元素个数
    volatile private int size = 0;

    // 入队列
    public void put(int value) throws InterruptedException {
        synchronized (this) {
            while(size == items.length) {
                // 队列满了,要进行阻塞
                this.wait();
            }
            items[tail++] = value;
            // 如果 tail 达到数组末尾,就需要从头开始
            if(tail == items.length) {
                tail = 0;
            }
            size++;
            // 队列不空的时候(插入元素成功),就需要唤醒
            // notify 即使没人在等待,多调用几次 notify 也没啥副作用
            this.notify();
        }
    }

    // 出队列
    public Integer take() throws InterruptedException {
        int ret = 0;
        synchronized (this) {
            while(size == 0) {
                // 队列为空,就阻塞等待
                this.wait();// wait 方法需要在 synchronized 里面使用
            }
            ret = items[head++];
            if(size == items.length) {
                head = 0;
            }
            size--;
            // 队列不满(取走一个元素),就需要唤醒
            this.notify();
        }
        return ret;
    }
}

public class Demo21 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue queue = new MyBlockingQueue();

        // 消费者
        Thread customer = new Thread(() -> {
            while(true) {
                int value = 0;
                try {
                    value = queue.take();
                    System.out.println("消费:" + value);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        customer.start();

        // 生产者
        Thread producer = new Thread(() -> {
            int value = 0;
            while(true) {
                try {
                    queue.put(value);
                    System.out.println("生产" + value);
                    value++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        producer.start();
    }
}

到这里 , 阻塞队列的讲解就完毕了
对你有帮助的话请一键三连~
在这里插入图片描述

加勒比海涛
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
龙果 java并发编程原理实战
01-26
第49节Java中的阻塞队列原理与使用00:26:18分钟 | 第50节实战：简单实现消息队列00:11:07分钟 | 第51节并发容器ConcurrentHashMap原理与使用00:38:22分钟 | 第52节线程池的原理与使用00:42:49分钟 | 第53节...
Java并发编程原理与实战
08-14
了解多线程所带来的安全风险.mp4 从线程的优先级看饥饿问题.mp4 从Java字节码的角度看线程安全性问题.mp4 synchronized保证线程安全的原理（理论层面）.mp4 synchronized保证线程安全的原理（jvm层面）.mp4 单例问题...
JavaWeb———多线程的阻塞队列
char_m的博客
06-14 260
阻塞队列
JAVA 中IO总结 同步、异步、阻塞、非阻塞
公众号-老炮说Java
01-27 209
往期精选●架构师高并发高性能分布式教程(4000G) ● 39阶段精品云计算大数据实战视频教程● 互联网技术干货视频教程大全【菜单为准】● 2017年8月最新In...
实现Java阻塞有哪些方法
IT技术交流分享
01-22 6698
如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞，可以中断线程，并且通过抛出InterruptedException来唤醒它;如果线程遇到了IO阻塞，无能为力，因为IO是操作系统实现的，Java代码并没有办法直接接触到操作系统。以下是详细的唤醒方法： 1. sleep() 方法 sleep(毫秒)，指定以毫秒为单位的时间，使线程在该时间内进入线程阻塞状态，期间得...
Java中什么方法导致线程阻塞
热门推荐
Chin_Style的博客
03-24 3万+
一、为什么引入线程阻塞机制？ 为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。 阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系...
在web项目中使用sleep方法，会不会造成意外阻塞
松鼠病重度患者
06-17 2140
在项目中有一个功能，需要在一个方法中前后分开调用两个socket接口，在两次调用之间使用了sleep方法让线程休眠。 这时候有一个问题，如果该线程休眠以后，用户在web界面会不会进入卡顿的状态，在调用其他方法会有什么问题，重复调用被休眠的方法会有什么问题？ 经过测试以后，sleep确认对其他操作没有影响。因为tomcat容器是支持多线程的，即每次请求都会开启一条新线程来处理请求。具体的策...
Java Web 实战 10 - 多线程基础之线程池
m0_53117341的博客
03-13 471
使用线程池可以降低资源消耗 , 通过重复利用已创建的线程降低线程创建和销毁造成的消耗 . 还可以提高响应速度 , 当任务到达时，任务可以不需要等到线程创建就能立即执行 我们会从三个角度分析线程池 1. 线程池是什么 2. 标准库中的线程池 3. 我们自己实现一个线程池
Java Web 实战 09 - 多线程基础之定时器
m0_53117341的博客
03-13 418
定时器是一个线程工具，可以用于调度多个定时任务以后台线程的方式运行。 比如说，在开发中，我们需要做一些周期性的操作，比如每隔三分钟就清空一次文件夹，用定闹钟的方式人为的清空肯定是不合适的。这时就可以通过 Timer 和 TimerTask 类来实现，定时完成具体任务的功能。
Java Web 实战 06 - 多线程基础之 wait 和 notify 关键字
m0_53117341的博客
03-10 558
带来两个多线程中的关键字 : wait 和 notify , 他们俩的作用都是用来控制线程之间的执行顺序的 , 但是有什么区别 , 我们继续往下学习推荐大家进行查看
java环境部署
JiuMeilove的博客
06-04 397
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
finereport 9.0 Tomcat 集群-来自帆软
chenmingfa110的博客
06-07 577
APACHE_HOME ％为你的安装目录。对于每个新来的session，Apache按照节点配置中的lbfactor比重选择访问节点，如果某节点node1不能访问，则寻找下一可访问节点，并且将此node1就在该访问session的访问黑名单中，以后该session的访问直接不考虑node1，即使node1又可以访问了。注：由于这里三个tomcat全在一台机器上，所以需要修改三种类型的端口号，如果是在不同的机器上，则只需要修改AJP13的connector的port，其他端口号不需要修改。
java中Overload和Override的区别
codedadi的博客
06-04 579
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 641
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
拼图小游戏
lazy_girl_666的博客
06-03 720
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。
线程池的工作原理
qq_42301955的博客
06-05 546
线程池总结
SpringBoot项目启动提示端口号占用
最新发布
点滴汇聚，智在积累。——Danny
06-07 89
通过netstat查看当前端口号并没有被占用啊，那可能是使用了系统保留端口，通过。1、换个端口（不在系统保留端口的范围）于是换个端口号试试，还是提示占用。2、关闭hyper-v。
Springboot vue3 elementplus 景点评论数据分析与可视化系统源码
scian22的博客
06-04 442
系统演示:链接：https://pan.baidu.com/s/1J056R4rYji_mc4gwteZEzg?
Java高级特性 - 多线程基础（3）线程同步
09-01
在Java的多线程编程中，线程同步是一个非常重要的概念。它用来确保多个线程在访问共享资源时不会产生冲突或竞争条件。在Java中，有几种方式可以实现线程同步，其中之一就是使用synchronized关键字。 synchronized...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

加勒比海涛

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

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

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

打赏作者

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

抵扣说明：

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

余额充值