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。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。