从零开始自己动手写阻塞队列

于 2022-08-14 12:44:24 发布
阅读量300 收藏 1
点赞数
分类专栏： python 文章标签： 计算机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56069948/article/details/126330470
版权

🚀 优质资源分享 🚀

学习路线指引（点击解锁）知识定位人群定位
🧡 Python实战微信订餐小程序 🧡进阶级本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。
💛Python量化交易实战💛入门级手把手带你打造一个易扩展、更安全、效率更高的量化交易系统

从零开始自己动手写阻塞队列

前言

在我们平时编程的时候一个很重要的工具就是容器，在本篇文章当中主要给大家介绍阻塞队列的原理，并且在了解原理之后自己动手实现一个低配版的阻塞队列。

需求分析

在前面的两篇文章ArrayDeque（JDK双端队列）源码深度剖析和深入剖析（JDK）ArrayQueue源码当中我们仔细介绍了队列的原理，如果大家感兴趣可以查看一下！

而在本篇文章所谈到的阻塞队列当中，是在并发的情况下使用的，上面所谈到的是队列是并发不安全的，但是阻塞队列在并发下情况是安全的。阻塞队列的主要的需求如下：

  • 队列基础的功能需要有，往队列当中放数据，从队列当中取数据。
  • 所有的队列操作都要是并发安全的。
  • 当队列满了之后再往队列当中放数据的时候，线程需要被挂起，当队列当中的数据被取出，让队列当中有空间的时候线程需要被唤醒。
  • 当队列空了之后再往队列当中取数据的时候，线程需要被挂起，当有线程往队列当中加入数据的时候被挂起的线程需要被唤醒。
  • 在我们实现的队列当中我们使用数组去存储数据，因此在构造函数当中需要提供数组的初始大小，设置用多大的数组。

阻塞队列实现原理

线程阻塞和唤醒

在上面我们已经谈到了阻塞队列是并发安全的，而且我们还有将线程唤醒和阻塞的需求，因此我们可以选择可重入锁ReentrantLock保证并发安全，但是我们还需要将线程唤醒和阻塞，因此我们可以选择条件变量Condition进行线程的唤醒和阻塞操作，在Condition当中我们将会使用到的，主要有以下两个函数：

  • signal用于唤醒线程，当一个线程调用Condition的signal函数的时候就可以唤醒一个被await函数阻塞的线程。
  • await用于阻塞线程，当一个线程调用Condition的await函数的时候这个线程就会阻塞。

数组循环使用

因为队列是一端进一端出，因此队列肯定有头有尾。

当我们往队列当中加入一些数据之后，队列的情况可能如下：

在上图的基础之上我们在进行四次出队操作，结果如下：

在上面的状态下，我们继续加入8个数据，那么布局情况如下：

我们知道上图在加入数据的时候不仅将数组后半部分的空间使用完了，而且可以继续使用前半部分没有使用过的空间，也就是说在队列内部实现了一个循环使用的过程。

为了保证数组的循环使用，我们需要用一个变量记录队列头在数组当中的位置，用一个变量记录队列尾部在数组当中的位置，还需要有一个变量记录队列当中有多少个数据。

代码实现

成员变量定义

根据上面的分析我们可以知道，在我们自己实现的类当中我们需要有如下的类成员变量：



|  | // 用于保护临界区的锁 |
|  | private final ReentrantLock lock; |
|  | // 用于唤醒取数据的时候被阻塞的线程 |
|  | private final Condition notEmpty; |
|  | // 用于唤醒放数据的时候被阻塞的线程 |
|  | private final Condition notFull; |
|  | // 用于记录从数组当中取数据的位置 也就是队列头部的位置 |
|  | private int takeIndex; |
|  | // 用于记录从数组当中放数据的位置 也就是队列尾部的位置 |
|  | private int putIndex; |
|  | // 记录队列当中有多少个数据 |
|  | private int count; |
|  | // 用于存放具体数据的数组 |
|  | private Object[] items; |

构造函数

我们的构造函数也很简单，最核心的就是传入一个数组大小的参数，并且给上面的变量进行初始化赋值。



|  | @SuppressWarnings("unchecked") |
|  | public MyArrayBlockingQueue(int size) { |
|  | this.lock = new ReentrantLock(); |
|  | this.notEmpty = lock.newCondition(); |
|  | this.notFull = lock.newCondition(); |
|  | // 其实可以不用初始化 类会有默认初始化 默认初始化为0 |
|  |  takeIndex = 0; |
|  |  putIndex = 0; |
|  |  count = 0; |
|  | // 数组的长度肯定不能够小于0 |
|  | if (size <= 0) |
|  | throw new RuntimeException("size can not be less than 1"); |
|  |  items = (E[])new Object[size]; |
|  | } |
|  |  |

put函数

这是一个比较重要的函数了，在这个函数当中如果队列没有满，则直接将数据放入到数组当中即可，如果数组满了，则需要将线程挂起。



|  | public void put(E x){ |
|  | // put 函数可能多个线程调用 但是我们需要保证在给变量赋值的时候只能够有一个线程 |
|  | // 因为如果多个线程同时进行赋值的话 那么可能后一个线程的赋值操作覆盖了前一个线程的赋值操作 |
|  | // 因此这里需要上锁 |
|  |  lock.lock(); |
|  |  |
|  | try { |
|  | // 如果队列当中的数据个数等于数组的长度的话 说明数组已经满了 |
|  | // 这个时候需要将线程挂起 |
|  | while (count == items.length) |
|  |  notFull.await(); // 将调用 await的线程挂起 |
|  | // 当数组没有满 或者在挂起之后再次唤醒的话说明数组当中有空间了 |
|  | // 这个时候需要将数组入队  |
|  | // 调用入队函数将数据入队 |
|  |  enqueue(x); |
|  |  } catch (InterruptedException e) { |
|  |  e.printStackTrace(); |
|  |  } finally { |
|  | // 解锁 |
|  |  lock.unlock(); |
|  |  } |
|  | } |
|  |  |
|  | // 将数据入队 |
|  | private void enqueue(E x) { |
|  | this.items[putIndex] = x; |
|  | if (++putIndex == items.length) |
|  |  putIndex = 0; |
|  |  count++; |
|  |  notEmpty.signal(); // 唤醒一个被 take 函数阻塞的线程唤醒 |
|  | } |
|  |  |

offer函数

offer函数和put函数一样，但是与put函数不同的是，当数组当中数据填满之后offer函数返回false，而不是被阻塞。



|  | public boolean offer(E e) { |
|  | final ReentrantLock lock = this.lock; |
|  |  lock.lock(); |
|  | try { |
|  | // 如果数组满了 则直接返回false 而不是被阻塞 |
|  | if (count == items.length) |
|  | return false; |
|  | else { |
|  | // 如果数组没有满则直接入队 并且返回 true |
|  |  enqueue(e); |
|  | return true; |
|  |  } |
|  |  } finally { |
|  |  lock.unlock(); |
|  |  } |
|  | } |
|  |  |

add函数

这个函数和上面两个函数作用一样，也是往队列当中加入数据，但当单队列满了之后这个函数会抛出异常。



|  | public boolean add(E e) { |
|  | if (offer(e)) |
|  | return true; |
|  | else |
|  | throw new RuntimeException("Queue full"); |
|  | } |
|  |  |

take函数

这个函数主要是从队列当中取出一个数据，但是当队列为空的时候，这个函数会阻塞调用该函数的线程：



|  | public E take() throws InterruptedException { |
|  | // 这个函数也是不能够并发的 否则可能不同的线程取出的是同一个位置的数据 |
|  | // 进行加锁操作 |
|  |  lock.lock(); |
|  | try { |
|  | // 当 count 等于0 说明队列为空 |
|  | // 需要将线程挂起等待 |
|  | while (count == 0) |
|  |  notEmpty.await(); |
|  | // 当被唤醒之后进行出队操作 |
|  | return dequeue(); |
|  |  }finally { |
|  |  lock.unlock(); |
|  |  } |
|  | } |
|  |  |
|  | private E dequeue() { |
|  | final Object[] items = this.items; |
|  | @SuppressWarnings("unchecked") |
|  | E x = (E) items[takeIndex]; |
|  |  items[takeIndex] = null; // 将对应的位置设置为 null GC就可以回收了 |
|  | if (++takeIndex == items.length) |
|  |  takeIndex = 0; |
|  |  count--; // 队列当中数据少一个了 |
|  | // 因为出队了一个数据 可以唤醒一个被 put 函数阻塞的线程 如果这个时候没有被阻塞的线程 |
|  | // 这个函数就不会起作用 也就说在这个函数调用之后被 put 函数挂起的线程也不会被唤醒 |
|  |  notFull.signal(); // 唤醒一个被 put 函数阻塞的线程 |
|  | return x; |
|  | } |

重写toString函数

因为我们在后面的测试函数当中会打印我们这个类，而打印这个类的时候会调用对象的toString方法得到一个字符串，最后打印这个字符串。



|  | @Override |
|  | public String toString() { |
|  | StringBuilder stringBuilder = new StringBuilder(); |
|  |  stringBuilder.append("["); |
|  | // 这里需要上锁 因为我们在打印的时候需要打印所有的数据 |
|  | // 打印所有的数据就需要对数组进行遍历操作 而在进行遍历 |
|  | // 操作的时候是不能进行插入和删除操作的 因为打印的是某 |
|  | // 个时刻的数据 |
|  |  lock.lock(); |
|  | try { |
|  | if (count == 0) |
|  |  stringBuilder.append("]"); |
|  | else { |
|  | int cur = 0; |
|  | // 对数据进行遍历 一共遍历 count 次 因为数组当中一共有 count |
|  | // 个数据 |
|  | while (cur != count) { |
|  | // 从 takeIndex 位置开始进行遍历 因为数据是从这个位置开始的 |
|  |  stringBuilder.append(items[(cur + takeIndex) % items.length].toString() + ", "); |
|  |  cur += 1; |
|  |  } |
|  | // 删除掉最后一次没用的 ", " |
|  |  stringBuilder.delete(stringBuilder.length() - 2, stringBuilder.length()); |
|  |  stringBuilder.append(']'); |
|  |  } |
|  |  }finally { |
|  |  lock.unlock(); |
|  |  } |
|  | return stringBuilder.toString(); |
|  | } |
|  |  |

完整代码

整个我们自己完成的阻塞队列的代码如下：



|  | import java.util.concurrent.locks.Condition; |
|  | import java.util.concurrent.locks.ReentrantLock; |
|  |  |
|  | public class MyArrayBlockingQueue { |
|  |  |
|  | // 用于保护临界区的锁 |
|  | private final ReentrantLock lock; |
|  | // 用于唤醒取数据的时候被阻塞的线程 |
|  | private final Condition notEmpty; |
|  | // 用于唤醒放数据的时候被阻塞的线程 |
|  | private final Condition notFull; |
|  | // 用于记录从数组当中取数据的位置 也就是队列头部的位置 |
|  | private int takeIndex; |
|  | // 用于记录从数组当中放数据的位置 也就是队列尾部的位置 |
|  | private int putIndex; |
|  | // 记录队列当中有多少个数据 |
|  | private int count; |
|  | // 用于存放具体数据的数组 |
|  | private Object[] items; |
|  |  |
|  |  |
|  | @SuppressWarnings("unchecked") |
|  | public MyArrayBlockingQueue(int size) { |
|  | this.lock = new ReentrantLock(); |
|  | this.notEmpty = lock.newCondition(); |
|  | this.notFull = lock.newCondition(); |
|  | // 其实可以不用初始化 类会有默认初始化 默认初始化为0 |
|  |  takeIndex = 0; |
|  |  putIndex = 0; |
|  |  count = 0; |
|  | if (size <= 0) |
|  | throw new RuntimeException("size can not be less than 1"); |
|  |  items = (E[])new Object[size]; |
|  |  } |
|  |  |
|  | public void put(E x){ |
|  |  lock.lock(); |
|  |  |
|  | try { |
|  | while (count == items.length) |
|  |  notFull.await(); |
|  |  enqueue(x); |
|  |  } catch (InterruptedException e) { |
|  |  e.printStackTrace(); |
|  |  } finally { |
|  |  lock.unlock(); |
|  |  } |
|  |  } |
|  |  |
|  | private void enqueue(E x) { |
|  | this.items[putIndex] = x; |
|  | if (++putIndex == items.length) |
|  |  putIndex = 0; |
|  |  count++; |
|  |  notEmpty.signal(); |
|  |  } |
|  |  |
|  | private E dequeue() { |
|  | final Object[] items = this.items; |
|  | @SuppressWarnings("unchecked") |
|  | E x = (E) items[takeIndex]; |
|  |  items[takeIndex] = null; |
|  | if (++takeIndex == items.length) |
|  |  takeIndex = 0; |
|  |  count--; |
|  |  notFull.signal(); |
|  | return x; |
|  |  } |
|  |  |
|  | public boolean add(E e) { |
|  | if (offer(e)) |
|  | return true; |
|  | else |
|  | throw new RuntimeException("Queue full"); |
|  |  } |
|  |  |
|  | public boolean offer(E e) { |
|  | final ReentrantLock lock = this.lock; |
|  |  lock.lock(); |
|  | try { |
|  | if (count == items.length) |
|  | return false; |
|  | else { |
|  |  enqueue(e); |
|  | return true; |
|  |  } |
|  |  } finally { |
|  |  lock.unlock(); |
|  |  } |
|  |  } |
|  |  |
|  | public E poll() { |
|  | final ReentrantLock lock = this.lock; |
|  |  lock.lock(); |
|  | try { |
|  | return (count == 0) ? null : dequeue(); |
|  |  } finally { |
|  |  lock.unlock(); |
|  |  } |
|  |  } |
|  |  |
|  | public E take() throws InterruptedException { |
|  |  lock.lock(); |
|  | try { |
|  | while (count == 0) |
|  |  notEmpty.await(); |
|  | return dequeue(); |
|  |  }finally { |
|  |  lock.unlock(); |
|  |  } |
|  |  } |
|  |  |
|  | @Override |
|  | public String toString() { |
|  | StringBuilder stringBuilder = new StringBuilder(); |
|  |  stringBuilder.append("["); |
|  |  lock.lock(); |
|  | try { |
|  | if (count == 0) |
|  |  stringBuilder.append("]"); |
|  | else { |
|  | int cur = 0; |
|  | while (cur != count) { |
|  |  stringBuilder.append(items[(cur + takeIndex) % items.length].toString()).append(", "); |
|  |  cur += 1; |
|  |  } |
|  |  stringBuilder.delete(stringBuilder.length() - 2, stringBuilder.length()); |
|  |  stringBuilder.append(']'); |
|  |  } |
|  |  }finally { |
|  |  lock.unlock(); |
|  |  } |
|  | return stringBuilder.toString(); |
|  |  } |
|  |  |
|  | } |
|  |  |

现在对上面的代码进行测试：

我们现在使用阻塞队列模拟一个生产者消费者模型，设置阻塞队列的大小为5，生产者线程会往队列当中加入数据，数据为0-9的10个数字，消费者线程一共会消费10次。



|  | import java.util.concurrent.TimeUnit; |
|  |  |
|  | public class Test { |
|  |  |
|  | public static void main(String[] args) throws InterruptedException { |
|  |  MyArrayBlockingQueue queue = new MyArrayBlockingQueue<>(5); |
|  | Thread thread = new Thread(() -> { |
|  | for (int i = 0; i < 10; i++) { |
|  |  System.out.println(Thread.currentThread().getName() + " 往队列当中加入数据：" + i); |
|  |  queue.put(i); |
|  |  } |
|  |  }, "生产者"); |
|  |  |
|  |  |
|  | Thread thread1 = new Thread(() -> { |
|  | for (int i = 0; i < 10; i++) { |
|  | try { |
|  |  System.out.println(Thread.currentThread().getName() + " 从队列当中取出数据：" + queue.take()); |
|  |  System.out.println(Thread.currentThread().getName() + " 当前队列当中的数据：" + queue); |
|  |  } catch (InterruptedException e) { |
|  |  e.printStackTrace(); |
|  |  } |
|  |  } |
|  |  }, "消费者"); |
|  |  thread.start(); |
|  |  TimeUnit.SECONDS.sleep(3); |
|  |  thread1.start(); |
|  |  |
|  |  } |
|  | } |
|  |  |

上面代码的输出如下所示：



|  | 生产者 往队列当中加入数据：0 |
|  | 生产者 往队列当中加入数据：1 |
|  | 生产者 往队列当中加入数据：2 |
|  | 生产者 往队列当中加入数据：3 |
|  | 生产者 往队列当中加入数据：4 |
|  | 生产者 往队列当中加入数据：5 |
|  | 消费者 从队列当中取出数据：0 |
|  | 生产者 往队列当中加入数据：6 |
|  | 消费者 当前队列当中的数据：[1, 2, 3, 4, 5] |
|  | 消费者 从队列当中取出数据：1 |
|  | 消费者 当前队列当中的数据：[2, 3, 4, 5] |
|  | 消费者 从队列当中取出数据：2 |
|  | 消费者 当前队列当中的数据：[3, 4, 5, 6] |
|  | 生产者 往队列当中加入数据：7 |
|  | 消费者 从队列当中取出数据：3 |
|  | 消费者 当前队列当中的数据：[4, 5, 6, 7] |
|  | 消费者 从队列当中取出数据：4 |
|  | 消费者 当前队列当中的数据：[5, 6, 7] |
|  | 消费者 从队列当中取出数据：5 |
|  | 消费者 当前队列当中的数据：[6, 7] |
|  | 生产者 往队列当中加入数据：8 |
|  | 消费者 从队列当中取出数据：6 |
|  | 消费者 当前队列当中的数据：[7, 8] |
|  | 消费者 从队列当中取出数据：7 |
|  | 消费者 当前队列当中的数据：[8] |
|  | 消费者 从队列当中取出数据：8 |
|  | 消费者 当前队列当中的数据：[] |
|  | 生产者 往队列当中加入数据：9 |
|  | 消费者 从队列当中取出数据：9 |
|  | 消费者 当前队列当中的数据：[] |
|  |  |

从上面的输出结果我们知道，生产者线程打印5之后被挂起了，因为如果没有被挂起，生产者线程肯定可以一次性输出完成，因为消费者线程阻塞了3秒。但是他没有输出完成说明在打印5之后，因为阻塞队列满了，因而生产者线程被挂起了。然后消费者开始消费，这样阻塞队列当中就有空间了，生产者线程就可以继续生产了。

总结

在本篇文章当中，主要向大家介绍了阻塞队列的原理并且实现了一个低配版的数组阻塞队列，其实如果你了解数组队列和锁的话，这个代码实现起来还是相对比较简单的，我们只需要使用锁去保证我们的程序并发安全即可。

  • 我们在实现put函数的时候，如果当前队列已经满了，则当前线程需要调用await函数进行阻塞，当线程被唤醒或者队列没有满可以继续执行的时候，我们在往队列当中加入数据之后需要调用一次signal函数，因为这样可以唤醒在调用take函数的时候因为队列空而阻塞的线程。
  • 我们实现take函数的时候，如果当前队列已经空了，则当前线程也需要调用await函数进行阻塞，当线程被唤醒或者队列不为空线程可以继续执行，在出队之后需要调用一次signal函数，因为这样可以唤醒在调用put函数的时候因为队列满而阻塞的线程。

以上就是本篇文章的所有内容了，我是LeHung，我们下期再见！！！更多精彩内容合集可访问项目：https://github.com/Chang-LeHung/CSCore

关注公众号：一无是处的研究僧，了解更多计算机（Java、Python、计算机系统基础、算法与数据结构）知识。

[虚幻私塾】
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于wait/notify的阻塞队列
qq_22158743的博客
05-19 389
阻塞队列与普通的队列的区别就是当队列为空或者满时处理的逻辑不通，普通队列返回特殊值（比如null，false等等）而阻塞队列是阻塞当前线程直到队列有元素或者不为空。 下面我们使用Java中的wait/notify方法来实现一个自己的阻塞队列。 首先定义阻塞队列的接口： public interface BlockingQueue<E>{ /** * 往队列尾部...
WenOS_任务调度（内核文件）.zip
08-17
创建一个自己的操作系统内核是一项复杂的挑战，但也是学习计算机科学精髓的绝佳途径。"WenOS_任务调度（内核文件）.zip"这个压缩包可能包含了制作一个自定义操作系统内核的教程，特别是关于任务调度的部分，这是操作...
手写JDK组件之阻塞队列BlockedQueue
weixin_30312563的博客
08-20 243
研究了一段时间框架，有点审美疲劳，今天讲点轻松的，手写一个阻塞队列，实践一把lock+condition。 “等待通知”机制 首先复习一下经典的 “等待通知”机制。 线程首先获取互斥锁，当线程要求的条件不满足时，释放互斥锁，进入等待状态；当要求的条件满足时，通知等待的线程，重新获取互斥锁 --《极客时间-Java并发编程实战》 在Java中实现 “等待通知” 机制一般有两种方式，s...
从0到1实现自己的阻塞队列
qq_38482920的博客
04-07 237
什么是阻塞队列？ 阻塞队列是这样的一种数据结构，它是一个队列（类似于一个List）,可以存放0到N个元素。我们可以对这个队列执行插入或弹出元素操作，弹出元素操作就是获取队列中的第一个元素，并且将其从队列中移除；而插入操作就是将元素添加到队列的末尾。当队列中没有元素时，对这个队列的弹出操作将会被阻塞，直到有元素被插入时才会被唤醒；当队列已满时，对这个队列的插入操作就会被阻塞，直到有元素被弹出后才会被唤醒。 在线程池中，往往就会用阻塞队列来保存那些暂时没有空闲线程可以直接执行的任务，等到线程空闲之后再从阻塞
Java中阻塞队列的几种实现方式
记忆碎片
10-09 8486
1.wait()和notify()方式(摘自:https://segmentfault.com/a/1190000000373535) 阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程
java.util.concurrent.locks.Condition 例子程序探讨
jiang0的博客
05-24 238
API文档上例子如下： class BoundedBuffer { final Lock lock = new ReentrantLock(); 下面使用两个condition是否有必要？ final Condition notFull = lock.newCondition(); final Condition notEmpty = lock.newCondit...
自己手写nio和netty，不建议下载
04-01
手写NIO和Netty意味着尝试从零开始实现这些功能，这可以帮助深入理解底层原理，但通常并不推荐，因为Netty已经经过了大量的优化和测试，而且社区支持强大，可以直接使用而无需重新造轮子。 总之，NIO是一种改进的I/...
【Swoole 从入门到实战】学习笔记，从零开始学 Swoole，包括 Swoole Task，Swoole Web.zip
最新发布
02-22
《Swoole 从入门到实战》学习笔记涵盖了Swoole的基础知识以及其在实际应用中的高级特性，特别强调了Swoole Task和Swoole Web Server的使用。以下是对这些知识点的详细解读： Swoole是一个高性能的PHP扩展，它为PHP...
31-从零移植uCOS到STM8 20181127
11-27
在本教程中，我们将深入探讨如何将uCOS操作系统从零开始移植到STM8平台上，从而充分利用其硬件资源，实现高效的多任务并发执行。 首先，我们需要了解uCOS的基本结构。uCOS是一个抢占式实时操作系统，它提供了任务...
java从刚刚开始到集合的详细代码和笔记教程.rar
11-20
本教程旨在为初学者提供一个从零基础到掌握Java集合框架的全面学习路径。 一、Java基础知识 1. **环境搭建**：首先，学习Java需要安装Java Development Kit (JDK)，配置JAVA_HOME环境变量，了解命令行工具javac...
Java实现简单的阻塞队列2种方式
06-10
Java实现简单的阻塞队列2种方式，1使用wait()，notify();2使用countdownlatch实现
java 阻塞队列自定义实现
fjkxyl的博客
03-21 1917
自定义阻塞队列：思路==》阻塞队列有这样一个特点，当队列中没有值得时候，这是只允许值得插入，当队列中有值得时候，这时候允许队列的插入，同时也允许队列中元素的移除，但是当队列中没有值得时候，这时候就不允许队列的移除了，而是等待其他线程插入新的元素 public class BlockingQueue {      private LinkedList list = new
java 实现阻塞队列_Java实现自定义阻塞队列
weixin_39726873的博客
02-12 186
今天重温了下 java 多线程中的 notify()方法以及 wait() 方法，一时兴起，决定通过这俩个方法，实现一个简易的自定义阻塞队列。阻塞队列是什么，与普通队列的区别是什么？阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样...
[Java 并发编程] 21. 阻塞队列
孙广明的博客
09-07 281
文章目录一、阻塞队列（Blocking Queues）二、BlockingQueues的实现 一、阻塞队列（Blocking Queues） Blocking Queues 是当你尝试从一个空队列取出一个元素时、或尝试从一个满队列做插入一个元素时会被阻塞的队列。 包含： 一个线程尝试从空队列做出队操作时会被阻塞，直到其他线程插入一个元素至队列中。 一个线程尝试从满队列做入队操作时会被阻塞，直到其他线程消耗队列中的一个或多个元素、或清空队列。 Java 5 提供了 java.util.concurr
阻塞队列 java实现_Java实现自定义阻塞队列
weixin_33162568的博客
02-20 282
今天重温了下 java 多线程中的 notify()方法以及 wait() 方法，一时兴起，决定通过这俩个方法，实现一个简易的自定义阻塞队列。阻塞队列是什么，与普通队列的区别是什么？阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样...
自己动手实现一个阻塞队列
weixin_45032957的博客
04-22 510
阻塞队列接口 为了降低复杂度，我们的阻塞队列只提供最基础的出队、入队和判空接口。 复制代码 /** 阻塞队列 首先是一个先进先出的队列 提供特别的api，在入队时如果队列已满令当前操作线程阻塞；在出队时如果队列为空令当前操作线程阻塞 单个元素的插入、删除操作是线程安全的 */ public interface MyBlockingQueue { /** 插入特定元素e，加入队尾 队列已满时阻塞当前线程，直到队列中元素被其它线程删除并插入成功 */ void put(E e) t
Java知识点06：队列(Queue)的offer/add函数,poll/remove函数,peek/element函数的区别
gao_jun1的博客
09-13 6297
一、Queue接口的描述 Queue接口，实现了 Collection接口。 队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。 在Queue中，有 offer、add、poll、remove、peek、element六个方法 public interface Queue<E> extends Collection<E> { boolean add(E e); boolean offer(E e); E remove(); .
如何用Java设计阻塞队列，再说说ArrayBlocking和LinkedBlocking
weixin_47067712的博客
06-17 140
前言 用Java如何设计一个阻塞队列，这个问题是在面滴滴的时候被问到的。当时确实没回答好，只是说了用个List，然后消费者再用个死循环一直去监控list的是否有值，有值的话就处理List里面的内容。回头想想，自己真是一个大傻X，也只有我才会这么设计一个阻塞队列（再说，我这也不是阻塞的队列）。 结果自己面试完之后，也没去总结这部分知识，然后过了一段时间，某教育机构的面试又被问到类似的问题了，只不过是换了一个形式，“请用wait方法和notify方法实现一套有生产者和消费者的这种逻辑”。然后我就又蒙圈了，追悔莫
【JAVA】阻塞队列如何实现？分析JDK 阻塞队列源码实现
三也_攻城狮
05-22 1427
阻塞队列，顾名思义，在队列操作时有阻塞机制，防止出现数据不一致，这里只分析两个API的操作源代码 offer(E e) 生产者，生产元素 1、加锁，ReentrantLock 加锁保证了不会同时有多个生产者来生产元素，达到阻塞，否则数据错误乱 2、判断当前队列里的元素数count，和队列容量capacity比较 判断是否可以往里面生产元素 3、数据入队 4、计数器++ 5...
java写一个阻塞队列
03-04
阻塞队列是一种线程安全的队列，当队列为空时，从队列中获取元素的操作会被阻塞，直到队列中有新的元素加入；当队列已满时，向队列中添加元素的操作会被阻塞，直到队列中有空闲位置。 Java中提供了多种阻塞队列的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

[虚幻私塾】

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

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

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

打赏作者

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

抵扣说明：

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

余额充值