爪哇中的ArrayBlockingQueue

在本文中，我们将了解Java并发队列BlockingQueue。然后我们将深入其中’其中之一的实现ArrayBlockingQueue。

什么是BlockingQueue

阻塞队列 整型erface was 整型roduced in 爪哇 5 under 同时 APIs and it represents a thread-safe queue in which elements can be added to and removed from. We can have multiple threads inserting and removing elements from 阻塞队列 同时ly.

The reason it is called blocking because it has the ability to block a thread from inserting an element when 这个 queue is full and also it blocks a thread from removing an element when 这个 queue is empty. Of course, there are different methods which decide whether to block the thread or 返回 an exception.

ArrayBlockingQueue

ArrayBlockingQueue实现BlockingQueue 爪哇接口。它是一个并发且有界的阻塞队列实现，它使用数组来存储元素。该类提供阻塞和非阻塞功能，用于从队列中插入和删除元素。通过阻塞它意味着像take（）和put（）这样的函数将无限期阻塞使用者或生产者线程，除非删除或插入一个元素。

产品特点

• 它是阻塞队列的线程安全实现。
• 它是一个有界队列，其大小在创建对象时给出，并且可以’实例化后将无法更改。队列是使用内部数组实现的。
• 可以按插入顺序或FIFO使用ArrayBlockingQueue上的元素。
• 不允许使用null对象，如果放在阻塞队列中的对象为null，则它将引发异常。
• 它具有阻塞和非阻塞功能，可以从队列中放置元素或从队列中删除元素。
• 它允许生产者或消费者线程的公平政策。公平政策将在下面详细说明

进一步阅读

爪哇中的自定义BlockingQueue实现

在本文中，我们将看到如何创建自己的自定义BlockingQueue。这是最常问的问题之一…
阅读更多

爪哇中的BlockingQueue

阻塞队列是在Java中与ConcurrentHashMap并发包一起引入的。是放置元素的线程安全队列…
阅读更多

爪哇 线程池执行器

爪哇 5引入了新的并发API（称为Executor框架），以简化程序员的生活。它简化了设计和开发…
阅读更多

建设者

The ArrayBlockingQueue has three constructors. The 公平ness flag set as 真正 implies that 如果 multiple Producer or 消费者 threads are waiting on the queue either for adding or removing an element from the queue then it will ensure a FIFO order for the waiting threads 其他 如果 it’假，然后不’t保证线程的顺序。

The ArrayBlockingQueue in 爪哇 整型ernally uses a Reentrant 锁 object instance. It also uses the 锁 to create two conditions 不是空的 and 不完整.

The 不是空的 condition will allow 消费者s to remove elements from the queue in a threadsafe manner and will block the 消费者 threads in case the queue gets full.

The 不完整 condition will in a similar way allow 制片人 threads to add elements in the queue in a thread-safe manner until it’满后，它将阻止所有生产者线程。

在第三 建设者，如果我们传递一个集合，则初始ArrayBlockingQueue将具有遍历顺序的那个集合的元素。

方法

ArrayBlockingQueue 有许多受支持的方法，我们将列出所有这些方法，此外，我们还添加了某些功能的实际实现的源代码片段，以便更好地理解。添加的功能的源代码片段有助于理解如何使用构造函数中初始化的锁和条件对象。

1. 提供(E)：此函数如下所示，将在队列的尾部添加一个元素，如果成功返回true，否则如果达到队列容量，它将返回false。它’s是线程安全的方法，并且是非阻塞的，即，如果队列已满，则将赢得’t阻止生产者线程，但返回false。
   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   上市 布尔值 提供(E e) {         checkNotNull(e);         最后 重入锁 锁 = 这个.锁;         锁.锁();         尝试 {             如果 (计数 == 项目.长度)                 返回 假;             其他 {                 入队(e);                 返回 真正;             }         } 最后 {             锁.开锁();         }     }

2. 提供(E e, 长 超时, 时间单位 单元)：此功能的行为与offer（E）相似，除了在阻塞队列已满的情况下，它没有’t会快速返回false，但是要等到超时值后，才能在阻塞队列返回false之前查看该空间是否在阻塞队列中可用于插入该元素。
   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   上市 布尔值 提供(E e, 长 超时, 时间单位 单元)         抛出 InterruptedException {           checkNotNull(e);         长 纳米 = 单元.往纳诺斯(超时);         最后 重入锁 锁 = 这个.锁;         锁.不断地锁定();         尝试 {             而 (计数 == 项目.长度) {                 如果 (纳米 <= 0)                     返回 假;                 纳米 = 不完整.等待纳米(纳米);             }             入队(e);             返回 真正;         } 最后 {             锁.开锁();         }     }

3. 放(E e)：此函数将在末尾将元素插入到阻塞队列中，并且将无限期等待，除非阻塞队列已满，除非插入中断。
   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   上市 虚空 放(E e) 抛出 InterruptedException {         checkNotNull(e);         最后 重入锁 锁 = 这个.锁;         锁.不断地锁定();         尝试 {             而 (计数 == 项目.长度)                 不完整.等待();             入队(e);         } 最后 {             锁.开锁();         }     }

   pre>

4. add(E)：此函数在内部使用offer（E）并以相同的方式运行，除了当阻塞队列已满时，它将引发IllegalStateException。

5. 轮询()：此函数删除并返回阻塞队列顶部的元素，如果队列为空，则返回null。这是一个非阻塞功能。
   1 2 3 4 5 6 7 8 9 10 11

   上市 E 轮询() {         最后 重入锁 锁 = 这个.锁;         锁.锁();         尝试 {             返回 (计数 == 0) ? 空值 : 出队();         } 最后 {             锁.开锁();         }     }

6. 轮询(long 超时, 时间单位 单元)：此函数的行为与poll函数类似，不同之处在于，如果阻塞队列为空，它将在尝试获取阻塞队列顶部的元素之前等待超时参数值。
   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   上市 E 轮询(长 超时, 时间单位 单元) 抛出 InterruptedException {         长 纳米 = 单元.往纳诺斯(超时);         最后 重入锁 锁 = 这个.锁;         锁.不断地锁定();         尝试 {             而 (计数 == 0) {                 如果 (纳米 <= 0)                     返回 空值;                 纳米 = 不是空的.等待纳米(纳米);             }             返回 出队();         } 最后 {             锁.开锁();         }     }

7. 采取()：如果队列不为空，则此函数将返回阻塞队列顶部的元素。如果阻塞队列为空，则调用此函数的线程将等待，直到将元素插入到阻塞队列中为止。
   1 2 3 4 5 6 7 8 9 10 11 12 13

   上市 E 采取() 抛出 InterruptedException {         最后 重入锁 锁 = 这个.锁;         锁.不断地锁定();         尝试 {             而 (计数 == 0)                 不是空的.等待();             返回 出队();         } 最后 {             锁.开锁();         }     }

8. peek()：此函数将返回阻塞队列顶部的元素，而不会删除该元素；如果阻塞队列为空，则返回null。

9. size()：此函数返回阻塞队列的容量

10. 剩余容量()：此函数返回阻止队列可容纳的最大元素数减去当前阻止队列中的元素数之差。

11. remove(Object o)：如果此元素等于传递给此函数的对象，则该函数从阻塞队列中删除该元素的单个实例。如果找到匹配的元素，则删除后返回true，否则返回false。

12. contains(Object o)：如果阻塞队列中存在与作为输入参数传递的对象匹配的对象，则此函数返回true，否则返回false。

13. toArray()：此函数返回一个Object []，它是支持阻塞队列的内部数组的有序副本。 系统.arraycopy（）用于复制数组，以确保对返回的数组进行外部修改’不会影响阻塞队列。

14. clear()：此函数将以原子方式删除阻塞队列中的所有元素。这还将在清空队列后向阻塞队列中等待的所有生产者线程发出信号。

15. drainTo()：此功能将以原子方式耗尽阻塞队列中的所有元素。如果您的集合参数实例与调用此函数的实例相同，则将引发IllegalArgumentException。任何等待中的生产者线程都将收到信号，表明队列为空并准备接受新元素。

使用场景

当不需要完整的消息传递基础结构时，可以使用ArrayBlockingQueue实例解决生产者和使用者类型的问题。如果资源有限，它可以用作资源池来限制使用者。

实施代码

在下面的单元测试中，我们创建一个ArrayBlockingQueue实例并启动生产者，以及生产者线程是否等待某个使用者线程创建的空间。同样，我们还测试了一旦队列为空，使用者线程是否等待元素添加到队列中。

概要

1. We have understood what a 同时 阻塞队列 is and why it is 进口ant in a multi-threaded environment.
2. We have also seen the implementation of 阻塞队列, i.e. ArrayBlockingQueue.
3. We have gone through the constructors and methods of the ArrayBlockingQueue.
4. We have implemented our own ArrayBlockingQueue and tested it with 制片人 and 消费者.

导入联系人

您可能还喜欢：

获取Java中的线程ID

将Java程序延迟几秒钟

如何使用Java中的线程打印偶数和奇数

为什么在对象类中使用wait（），notify（）和notifyAll（）方法

爪哇中的自定义BlockingQueue实现

爪哇中Runnable和Callable之间的区别

在Java中使用3个线程打印序列

爪哇 可运行示例

爪哇 Executor框架教程和示例

爪哇 ExecutorCompletionService

• 1
• 2
• 3
• 4
• ›