Java ArrayBlockingQueue用法及代码示例

ArrayBlockingQueue 类是一个由数组支持的有界阻塞队列。有界，意味着Queue的大小是固定的。一旦创建，容量就无法更改。尝试将元素放入已满队列将导致操作阻塞。同样，从空队列中获取元素的尝试也会被阻止。 ArrayBlockingQueue 的有界性最初可以绕过将容量作为 ArrayBlockingQueue 构造函数中的参数来实现。该队列对元素进行 FIFO(先进先出)排序。这意味着该队列的头部是该队列中存在的元素中最旧的元素。

该队列的尾部是该队列元素中的最新元素。新插入的元素总是插入到队列的尾部，而队列检索操作获取的元素则位于队列的头部。

这个类及其迭代器实现了所有可选方法集合和迭代器接口。这个类是以下类的成员Java集合框架.

ArrayBlockingQueue的层次结构

Hierarchy of ArrayBlockingQueue

这个类扩展了AbstractQueue并实施可串行化,可迭代<E>,集合<E>,BlockingQueue,Queue接口。

声明

public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, Serializable

这里，E是集合中存储的元素的类型。

Constructors of ArrayBlockingQueue

这里，容量是数组阻塞队列的大小。

1. ArrayBlockingQueue(intcapacity)：使用给定(固定)容量和默认访问策略创建ArrayBlockingQueue。

ArrayBlockingQueue<E> abq = new ArrayBlockingQueue<E>(int capacity);

2. ArrayBlockingQueue(int capacity, boolean fair)：创建具有给定(固定)容量和指定访问策略的ArrayBlockingQueue。如果公平值为 true，则插入或删除时阻塞的线程的队列访问将按 FIFO 顺序处理；如果为 false，则未指定访问顺序。

ArrayBlockingQueue<E> abq = new ArrayBlockingQueue<E>(int capacity, boolean fair);

3. ArrayBlockingQueue(int capacity, boolean fair, Collection c)：创建一个ArrayBlockingQueue，具有给定的(固定)容量、指定的访问策略，并且最初包含给定集合的元素，并按集合迭代器的遍历顺序添加。如果公平值为 true，则插入或删除时阻塞的线程的队列访问将按 FIFO 顺序处理；如果为 false，则未指定访问顺序。

ArrayBlockingQueue<E> abq = new ArrayBlockingQueue<E>(int capacity, boolean fair, Collection c);

例子：

Java


// Java program to demonstrate  
// ArrayBlockingQueue(int initialCapacity) 
// constructor 
  
import java.util.concurrent.ArrayBlockingQueue; 
  
public class ArrayBlockingQueueDemo { 
  
    public static void main(String[] args) 
    { 
        // define capacity of ArrayBlockingQueue 
        int capacity = 15; 
  
        // create object of ArrayBlockingQueue 
        // using ArrayBlockingQueue(int initialCapacity) constructor 
        ArrayBlockingQueue<Integer> abq = new ArrayBlockingQueue<Integer>(capacity); 
  
        // add  numbers 
        abq.add(1); 
        abq.add(2); 
        abq.add(3); 
  
        // print queue 
        System.out.println("ArrayBlockingQueue:" + abq); 
    } 
}

输出：

ArrayBlockingQueue:[1, 2, 3]

Basic Operations

1. 添加元素

ArrayBlockingQueue.add()方法将作为参数传递给该方法的元素插入到该队列的尾部。如果添加的元素超出了队列的容量，那么该方法将抛出一个IllegalStateException。如果添加元素成功，此方法返回 true，否则将抛出 IllegalStateException。

Java


// Java Program to Demonstrate adding 
// elements to an ArrayBlockingQueue. 
  
import java.util.concurrent.ArrayBlockingQueue; 
  
public class AddingElementsExample { 
  
    public static void main(String[] args) 
    { 
        // define capacity of ArrayBlockingQueue 
        int capacity = 15; 
  
        // create object of ArrayBlockingQueue 
        ArrayBlockingQueue<Integer> abq = new ArrayBlockingQueue<Integer>(capacity); 
  
        // add  numbers 
        abq.add(1); 
        abq.add(2); 
        abq.add(3); 
  
        // print queue 
        System.out.println("ArrayBlockingQueue:" + abq); 
    } 
}

输出

ArrayBlockingQueue:[1, 2, 3]

2. 删除元素

remove(Object o) 方法会从此队列中删除指定元素的单个实例(如果存在)。我们可以说，如果该队列包含一个或多个这样的元素，则该方法会删除一个元素 e，使得 o.equals(e) 。如果此队列包含我们要删除的指定元素，Remove() 方法将返回 true。

Java


// Java program to demonstrate removal of  
// elements from an AbstractQueue 
  
import java.util.concurrent.ArrayBlockingQueue; 
  
public class RemovingElementsExample { 
  
    public static void main(String[] args) 
    { 
        // define capacity of ArrayBlockingQueue 
        int capacity = 15; 
  
        // create object of ArrayBlockingQueue 
        ArrayBlockingQueue<Integer> abq = new ArrayBlockingQueue<Integer>(capacity); 
  
        // add  numbers 
        abq.add(1); 
        abq.add(2); 
        abq.add(3); 
  
        // print queue 
        System.out.println("ArrayBlockingQueue:" + abq); 
  
        // remove 223 
        boolean response = abq.remove(2); 
  
        // print Queue 
        System.out.println("Removal of 2 :" + response); 
  
        // print Queue 
        System.out.println("queue contains " + abq); 
  
        // remove all the elements 
        abq.clear(); 
  
        // print queue 
        System.out.println("ArrayBlockingQueue:" + abq); 
    } 
}

输出

ArrayBlockingQueue:[1, 2, 3]
Removal of 2 :true
queue contains [1, 3]
ArrayBlockingQueue:[]

3. 访问元素

ArrayBlockingQueue.peek()提供的方法队列接口用于返回队列的头。它检索但不删除该队列的头部。如果队列为空，则此方法返回 null。

Java


// Java program to demonstrate accessing 
// elements of ArrayBlockingQueue 
  
import java.util.concurrent.ArrayBlockingQueue; 
  
public class AccessingElementsExample { 
  
    public static void main(String[] args) 
    { 
  
        // Define capacity of ArrayBlockingQueue 
        int capacity = 5; 
  
        // Create object of ArrayBlockingQueue 
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(capacity); 
  
        // Add element to ArrayBlockingQueue 
        queue.add(23); 
        queue.add(32); 
        queue.add(45); 
        queue.add(12); 
  
        // Print queue after adding numbers 
        System.out.println("After adding numbers queue is "); 
        System.out.println(queue); 
  
        // Print head of queue using peek() method 
        System.out.println("Head of queue " + queue.peek()); 
    } 
}

输出

After adding numbers queue is 
[23, 32, 45, 12]
Head of queue 23

4. 遍历

ArrayBlockingQueue.iterator()的方法ArrayBlockingQueue类用于以适当的顺序返回与此队列相同的元素的迭代器。从此方法返回的元素包含按从第一个(头)到最后一个(尾)的顺序排列的元素。返回的迭代器是弱一致的。

Java


// Java Program to Demonstrate iterating 
// over ArrayBlockingQueue. 
  
import java.util.concurrent.ArrayBlockingQueue; 
import java.util.*; 
  
public class TraversingExample { 
  
    public static void main(String[] args) 
    { 
        // Define capacity of ArrayBlockingQueue 
        int capacity = 5; 
  
        // Create object of ArrayBlockingQueue 
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(capacity); 
  
        // Add 5 elements to ArrayBlockingQueue 
        queue.offer("User"); 
        queue.offer("Employee"); 
        queue.offer("Manager"); 
        queue.offer("Analyst"); 
        queue.offer("HR"); 
  
        // Print queue 
        System.out.println("Queue is " + queue); 
  
        // Call iterator() method and Create an iterator 
        Iterator iteratorValues = queue.iterator(); 
  
        // Print elements of iterator 
        System.out.println("\nThe iterator values:"); 
        while (iteratorValues.hasNext()) { 
            System.out.println(iteratorValues.next()); 
        } 
    } 
}

输出

Queue is [User, Employee, Manager, Analyst, HR]

The iterator values:
User
Employee
Manager
Analyst
HR

ArrayBlockingQueue的方法

这里，E是这个集合中保存的元素的类型

METHOD	DESCRIPTION
ArrayBlockingQueue.add()	如果可以在不超过队列容量的情况下立即插入指定元素，则将指定元素插入到此队列的尾部，成功时返回 true，如果此队列已满，则抛出 IllegalStateException。
clear()	以原子方式删除此队列中的所有元素。
contains(Object o)	如果此队列包含指定元素，则返回 true。
dropTo(Collection<? super E> c)	从此队列中删除所有可用元素并将它们添加到给定集合中。
dropTo(Collection<? super E> c, int maxElements)	从此队列中删除最多给定数量的可用元素并将它们添加到给定的集合中。
forEach(消费者<? super E> 操作)	对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常。
iterator()	按正确的顺序返回此队列中元素的迭代器。
ArrayBlockingQueue.offer()	如果可以在不超过队列容量的情况下立即插入指定元素，则将指定元素插入到此队列的尾部，成功时返回 true，如果队列已满，则返回 false。
ArrayBlockingQueue.offer()	在此队列的尾部插入指定的元素，如果队列已满，则等待指定的等待时间以获取可用空间。
put(E e)	将指定元素插入此队列的尾部，如果队列已满，则等待空间可用。
remainingCapacity()	返回此队列理想情况下(在没有内存或资源限制的情况下)可以无阻塞地接受的附加元素的数量。
ArrayBlockingQueue.remove()	从此队列中删除指定元素的单个实例(如果存在)。
移除全部(集合<?> c)	删除指定集合中也包含的所有该集合的元素(可选操作)。
removeIf(Predicate<? super E> 过滤器)	删除此集合中满足给定谓词的所有元素。
keepAll(集合<?> c)	仅保留此集合中包含在指定集合中的元素(可选操作)。
size()	返回此队列中的元素数量。
spliterator()	返回对此队列中元素的 Spliterator。
toArray()	返回一个数组，其中按正确的顺序包含此队列中的所有元素。
toArray(T[] a)	返回一个数组，其中包含此队列中的所有元素(按正确的顺序)；返回数组的运行时类型是指定数组的运行时类型。

类 java.util.AbstractQueue 中声明的方法

METHOD	DESCRIPTION
AbstractQueue addAll()	将指定集合中的所有元素添加到此队列。
AbstractQueue element()	检索但不删除此队列的头部。
AbstractQueue remove()	检索并删除此队列的头部。

类 java.util.AbstractCollection 中声明的方法

METHOD	DESCRIPTION
AbstractCollection containsAll()	如果此集合包含指定集合中的所有元素，则返回 true。
AbstractCollection isEmpty()	如果此集合不包含任何元素，则返回 true。
AbstractCollection toString()	返回此集合的字符串表示形式。

接口 java.util.concurrent.BlockingQueue 中声明的方法

METHOD	DESCRIPTION
BlockingQueue poll()	检索并删除此队列的头部，如果需要元素变得可用，则等待指定的等待时间。
BlockingQueue take()	检索并删除此队列的头部，如有必要，则等待直到有元素可用。

接口 java.util.Collection 中声明的方法

METHOD	DESCRIPTION
addAll(集合 <? 扩展 E> c)	将指定集合中的所有元素添加到此集合中(可选操作)。
containsAll(集合<?> c)	如果此集合包含指定集合中的所有元素，则返回 true。
equals(Object o)	比较指定对象与此集合是否相等。
hashCode()	返回此集合的哈希码值。
isEmpty()	如果此集合不包含任何元素，则返回 true。
parallelStream()	返回一个可能并行的 Stream 并以此集合作为其源。
stream()	返回以此集合作为源的顺序 Stream。
toArray(IntFunction<T[]> 生成器)	返回一个包含此集合中所有元素的数组，使用提供的生成器函数分配返回的数组。

接口 java.util.Queue 中声明的方法

METHOD	DESCRIPTION
Queue element()	检索但不删除此队列的头部。
Queue peek()	检索但不删除此队列的头部，如果此队列为空，则返回 null。
Queue poll()	检索并删除此队列的头部，如果此队列为空，则返回 null。
Queue remove()	检索并删除此队列的头部。

结论：ArrayBlockingQueue 一般用在线程安全环境中，您希望阻止对单个资源进行两个或多个操作，而只允许一个线程。此外，我们可以使用容量限制因子来阻塞线程。

参考：https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ArrayBlockingQueue.html

相关用法

注：本文由纯净天空筛选整理自Code_r大神的英文原创作品 ArrayBlockingQueue Class in Java。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。