AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【JavaEE】多线程代码实例：单例模式与阻塞队列BlockingQueue（二）

2023-02-17 150
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【JavaEE】多线程代码实例：单例模式与阻塞队列BlockingQueue

自实现阻塞队列：

实现阻塞队列的关键在于实现其阻塞的功能。其他的和普通的队列差不多。这里主要实现put和take方法：

1. 
2. class MyBlockingQueue{
3. 
4. //利用数组实现
5. private int[] arr=new int[1000];//设定数组长度为1000
6. 
7. private int size=0;//记录数组的内容长度
8. //利用end和begin两个指针使得数组变为循环数组（逻辑上的循环）
9. private int end=0;
10. private int begin=0;
11. 
12. //实现put方法
13. //阻塞考虑使用wait和notify进行唤醒（sleep不太靠谱）
14. public void put(int value) throws InterruptedException {
15. //判断是否满了（这里要用循环判断，因为在多线程当中，线程被唤醒的时候不一定不满）
16. //加锁保证原子性
17. synchronized (this){
18. while(size>= arr.length){
19. this.wait();
20.         }
21. //不满之后放入元素
22.             arr[end]=value;
23. //调整长度
24.             end++;
25.             size++;
26. //如果放满了则将end变为0
27. if(end>= arr.length){
28.                 end=0;
29.             }
30. //进行唤醒
31. this.notify();
32.         }
33.     }
34. //实现take方法
35. public int take() throws InterruptedException {
36. synchronized (this){
37. //判断是否为空
38. while (size==0){
39. this.wait();
40.             }
41. //不空之后开始取出元素
42. int ret=arr[begin];
43.             begin++;
44. if(begin>= arr.length){
45.                 begin=0;
46.             }
47.             size--;
48. this.notify();
49. return ret;
50.         }
51. 
52.     }
53. //长度
54. public synchronized int Size(){
55. return size;
56.     }
57. 
58. }
59. 
60. 
61. public class BlockingQueueDemo3 {
62. 
63. public static void main(String[] args) throws InterruptedException {
64. 
65.         MyBlockingQueue queue=new MyBlockingQueue();
66.         queue.put(100);
67.         queue.put(200);
68.         queue.put(300);
69.         System.out.println(queue.take());
70.         System.out.println(queue.take());
71.         System.out.println(queue.take());
72. 
73.     }
74. }

显然，当其中没有元素的时候就会阻塞等待。

生产者消费者模型：

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。

生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取。

首先，阻塞队列相当于一个缓冲区，它平衡了生产者和消费者之间的处理能力。

其次，阻塞队列使得生产者和消费者之间的进行了解耦合，也就是消费者不再是直接依赖生产者。

对于阻塞队列，生产者是添加元素的一方，消费者是取元素的一方，产品是阻塞队列的元素。生产者和消费者通过阻塞队列相互联系。

画个图演示一下：

我们举向游戏里面氪金的例子吧！！！

这样就会出现一个问题：服务器A和服务器B的耦合太高，一旦其中一个服务器出现了问题，就会导致另一个服务器也无法完成需求。就会出现一个服务器挂了，把另一个服务器也带走的情况。

并且，如果我们需要在此基础上加一个新的服务器参与其他相关的功能，比如日志，也是会有问题的！

那么如何解决这种情况呢？这就用到了当前的生产者消费者模型。生产者生成的资源，我们可以将其放到一个阻塞队列当中去，当有消费者需要消费的时候，就直接从该阻塞队列当中去取，如果队列中没有资源，就阻塞等待，等待生产者进行生产，当阻塞队列满的时候，生产者也要进行阻塞等待。这里的服务器A就是生产者，服务器BC就是消费者。所以我们可以利用该模型进行这样的设计：

生产者消费者模型的实现：

利用系统的BlockingQueue实现生产者消费者模型：

首先我们利用系统提供的BlockingQueue实现生产者消费者模型： 

1. import java.util.concurrent.BlockingQueue;
2. import java.util.concurrent.LinkedBlockingQueue;
3. 
4. public class BlockingQueueDemo2 {
5. public static void main(String[] args) {
6. //创建阻塞队列
7.         BlockingQueue<Integer>queue=new LinkedBlockingQueue<>();
8. //使用两个线程：一个线程充当生产者，一个线程充当消费者
9. //生产者
10.         Thread t1=new Thread(()->{
11. int count=0;
12. while(true){
13. try {
14.                     queue.put(count);
15.                     System.out.println("生产者生产："+count);
16.                     count++;
17.                     Thread.sleep(500);
18.                 } catch (InterruptedException e) {
19. throw new RuntimeException(e);
20.                 }
21.             }
22.         });
23.         Thread t2=new Thread(()->{
24. 
25. while(true){
26. try {
27. int ret=queue.take();
28.                     System.out.println("消费者消费："+ret);
29.                     Thread.sleep(500);
30.                 } catch (InterruptedException e) {
31. throw new RuntimeException(e);
32.                 }
33.             }
34.         });
35.         t1.start();
36.         t2.start();
37.     }
38. }

我们可以明确的看到，消费元素和生产元素是成对出现的。这就不会出现生产者没有生产出来的东西被消费的情况。

利用自实现的BlockingQueue实现生产者消费者模型：

1. 
2. class MyBlockingQueue1{
3. 
4. //利用数组实现
5. private int[] arr=new int[1000];//设定数组长度为1000
6. 
7. private int size=0;//记录数组的内容长度
8. //利用end和begin两个指针使得数组变为循环数组（逻辑上的循环）
9. private int end=0;
10. private int begin=0;
11. 
12. //实现put方法
13. //阻塞考虑使用wait和notify进行唤醒（sleep不太靠谱）
14. public void put(int value) throws InterruptedException {
15. //判断是否满了（这里要用循环判断，因为在多线程当中，线程被唤醒的时候不一定不满）
16. //加锁保证原子性
17. synchronized (this){
18. while(size>= arr.length){
19. this.wait();
20.             }
21. //不满之后放入元素
22.             arr[end]=value;
23. //调整长度
24.             end++;
25.             size++;
26. //如果放满了则将end变为0
27. if(end>= arr.length){
28.                 end=0;
29.             }
30. //进行唤醒
31. this.notify();
32.         }
33.     }
34. //实现take方法
35. public int take() throws InterruptedException {
36. synchronized (this){
37. //判断是否为空
38. while (size==0){
39. this.wait();
40.             }
41. //不空之后开始取出元素
42. int ret=arr[begin];
43.             begin++;
44. if(begin>= arr.length){
45.                 begin=0;
46.             }
47.             size--;
48. this.notify();
49. return ret;
50.         }
51. 
52.     }
53. //长度
54. public synchronized int Size(){
55. return size;
56.     }
57. 
58. }
59. 
60. 
61. public class BlockingQueueDemo4 {
62. public static void main(String[] args) throws InterruptedException {
63.         MyBlockingQueue1 queue1=new MyBlockingQueue1();
64. //生产者
65. Thread producer =new Thread(()->{
66. int count=0;
67. while(true){
68. try {
69.                     queue1.put(count);
70.                     System.out.println("生产者生产元素："+count);
71.                     count++;
72.                     Thread.sleep(500);
73.                 } catch (InterruptedException e) {
74. throw new RuntimeException(e);
75.                 }
76.             }
77.         });
78. 
79. //消费者
80. Thread customer =new Thread(()->{
81. while(true){
82. try {
83. int ret=queue1.take();
84.                     System.out.println("消费者消费元素："+ret);
85.                     Thread.sleep(500);
86.                 } catch (InterruptedException e) {
87. throw new RuntimeException(e);
88.                 }
89.             }
90.         });
91.         producer.start();
92.         customer.start();
93.     }
94. }

文章标签：
Java
容器
关键词：
javaee线程
线程代码
线程单例模式
线程阻塞队列
线程实例
渴望力量的土狗
目录
相关文章
栈江湖
|
10月前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式：助您写出线程安全的代码
`synchronized` 是 Java 中的关键字，用于实现线程同步，确保多个线程互斥访问共享资源。它通过内置的监视器锁机制，防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块，分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器，JDK 1.6 后引入了偏向锁、轻量级锁等优化措施，提高了性能。
栈江湖
376 3
左诗右码
|
11月前
|
供应链 安全 NoSQL
PHP 互斥锁：如何确保代码的线程安全？
在多线程和高并发环境中，确保代码段互斥执行至关重要。本文介绍了 PHP 互斥锁库 `wise-locksmith`，它提供多种锁机制（如文件锁、分布式锁等），有效解决线程安全问题，特别适用于电商平台库存管理等场景。通过 Composer 安装后，开发者可以利用该库确保在高并发下数据的一致性和安全性。
左诗右码
164 6
三三是该溜子
|
10月前
|
Java
【JavaEE】——多线程常用类
Callable的call方法，FutureTask类，ReentrantLock可重入锁和对比，Semaphore信号量（PV操作）CountDownLatch锁存器，
三三是该溜子
62 0
三三是该溜子
|
10月前
|
Java 关系型数据库 MySQL
【JavaEE“多线程进阶”】——各种“锁”大总结
乐/悲观锁，轻/重量级锁，自旋锁，挂起等待锁，普通互斥锁，读写锁，公不公平锁，可不可重入锁，synchronized加锁三阶段过程，锁消除，锁粗化
三三是该溜子
111 0
三三是该溜子
|
10月前
|
Java Go 调度
【JavaEE】——线程池大总结
线程数量问题解决方式，代码实现线程池，ThreadPoolExecutor（核心构造方法），参数的解释（面试：拒绝策略），Executors，工厂模式，工厂类
三三是该溜子
184 0
三三是该溜子
|
10月前
|
缓存 安全 Java
【JavaEE】——单例模式引起的多线程安全问题：“饿汉/懒汉”模式，及解决思路和方法（面试高频）
单例模式下，“饿汉模式”，“懒汉模式”，单例模式下引起的线程安全问题，解锁思路和解决方法
三三是该溜子
350 0
三三是该溜子
|
10月前
|
Java 调度
【JavaEE】——线程“饿死问题” wait && notify（面试高频）
【JaveEE】线程饿死问题，wait和notify，
三三是该溜子
112 0
三三是该溜子
|
10月前
|
Java 调度
【JavaEE】——线程的安全问题和解决方式
【JavaEE】——线程的安全问题和解决方式。为什么多线程运行会有安全问题，解决线程安全问题的思路，synchronized关键字的运用，加锁机制，“锁竞争”，几个变式
三三是该溜子
86 0
三三是该溜子
|
10月前
|
Java API 调度
【JavaEE】——多线程（join阻塞，计算，引用，状态）
【JavaEE】——多线程，join，sleep引起的线程阻塞，多线程提升计算效率，如何获取线程的引用和状态
三三是该溜子
235 0
三三是该溜子
|
10月前
|
Java 程序员 调度
【JavaEE】线程创建和终止，Thread类方法，变量捕获（7000字长文）
创建线程的五种方式，Thread常见方法（守护进程.setDaemon() ，isAlive），start和run方法的区别，如何提前终止一个线程，标志位，isinterrupted，变量捕获
三三是该溜子
519 0

热门文章

最新文章

  • 1
    【JUC】（1）带你重新认识进程与线程！！让你深层次了解线程运行的睡眠与打断！！
  • 2
    JUC系列之《CountDownLatch：同步多线程的精准发令枪 》
  • 3
    【JUC】（3）常见的设计模式概念分析与多把锁使用场景！！理解线程状态转换条件！带你深入JUC！！文章全程笔记干货！！
  • 4
    【JUC】（6）带你了解共享模型之 享元和不可变 模型并初步带你了解并发工具 线程池Pool，文章内还有饥饿问题、设计模式之工作线程的解决于实现
  • 5
    什么是线程池？它的工作原理？
  • 6
    【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
  • 7
    【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
  • 8
    NDM多线程下载器!实用的下载器,绿色版下载及安装教程
  • 9
    Python多线程与多进程性能对比：从原理到实战的深度解析
  • 10
    高并发Java爬虫的瓶颈分析与动态线程优化方案
  • 1
    Java多线程基础-6：线程安全问题及解决措施，synchronized关键字与volatile关键字（一）
    219
  • 2
    Java多线程基础-18：线程安全的集合类与ConcurrentHashMap
    459
  • 3
    Java 多线程系列Ⅶ（线程安全集合类）
    128
  • 4
    Java 多线程系列Ⅳ（单例模式+阻塞式队列+定时器+线程池）
    153
  • 5
    Java 多线程系列Ⅰ（创建线程+查看线程+Thread方法+线程状态）
    108
  • 6
    进程与线程（概念、并行、并发）
    184
  • 7
    多线程(JUC, ReentrantLock, 原子类, 线程池, 信号量 Semaphore, CountDownLatch)
    129
  • 8
    多线程(CAS, ABA问题, Runnable & Callable & 僵尸线程 & 孤儿进程)
    171
  • 9
    多线程(锁升级, 锁消除, 锁粗化)
    149
  • 10
    多线程(代码案例: 单例模式, 阻塞队列, 生产者消费者模型,定时器)
    142

    • 相关电子书

    更多
  • 多IO线程优化版
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    开箱即用-OSS无代理备份