Java 中的 LinkedBlockingQueue 类

LinkedBlockingQueue 是一个基于链接节点的阻塞队列，可以选择设置容量，如果容量给定，则 LinkedBlockingQueue 就是有界的，否则它就是无界的。LinkedBlockingQueue 的容量可以通过 LinkedBlockingQueue 的构造函数的参数来设置。这个队列按照 FIFO（先进先出） 的顺序来排序元素。这意味着该队列的头是在该队列中存在的最旧元素。这个队列的尾是该队列中存在的最新元素。新插入的元素总是插入到队列的尾部，在队列检索操作中获取的元素是从队列的头部获取的。与基于数组的队列相比，链式队列通常具有更高的吞吐量，但在大多数并发应用程序中预测性能表现较差。

如果未指定容量，则容量等于 Integer.MAX_VALUE 。当每次插入时，会动态地创建链接节点，直到队列的容量填满。此类及其迭代器实现了 Collection 和 Iterator 接口的所有可选方法。它是 Java 集合框架的成员。

LinkedBlockingQueue 的层次结构

LinkedBlockingQueue 类扩展了 AbstractQueue 并实现了 Serializable、Iterable、Collection、 BlockingQueue和 Queue 接口。

声明：

public class LinkedBlockingQueue extends AbstractQueue implements BlockingQueue, Serializable

E ：此集合中包含的元素的类型。

LinkedBlockingQueue 的构造器：

要构造一个 LinkedBlockingQueue，我们需要从 java.util.concurrent.LinkedBlockingQueue 导入它。在这里， capacity 是链接阻塞队列的大小。

1. LinkedBlockingQueue() ：创建一个容量为 Integer.MAX_VALUE 的 LinkedBlockingQueue。

LinkedBlockingQueue<E> lbq = new LinkedBlockingQueue<E>();

示例：

// Java program to demonstrate
// LinkedBlockingQueue() constructor
  
import java.util.concurrent.LinkedBlockingQueue;
  
public class LinkedBlockingQueueDemo {
  
    public static void main(String[] args)
    {
  
        // create object of LinkedBlockingQueue
        // using LinkedBlockingQueue() constructor
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>();
  
        // add  numbers
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);
        lbq.add(4);
        lbq.add(5);
  
        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}

输出：“`

LinkedBlockingQueue:[1, 2, 3, 4, 5]“`

2. LinkedBlockingQueue(int capacity) ：创建具有给定（固定）容量的 LinkedBlockingQueue。

LinkedBlockingQueue<E> lbq = new LinkedBlockingQueue(int capacity);

示例:

// Java程序演示
// LinkedBlockingQueue(int initialCapacity) 构造函数

import java.util.concurrent.LinkedBlockingQueue;

public class GFG {

    public static void main(String[] args)
    {
        // 定义LinkedBlockingQueue的容量
        int capacity = 15;

        // 使用LinkedBlockingQueue(int initialCapacity)构造函数
        // 创建LinkedBlockingQueue对象
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(capacity);

        // 添加数字
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);

        // 打印队列
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}

输出

LinkedBlockingQueue:[1, 2, 3]

**3. LinkedBlockingQueue(Collection c) ** : 创建一个LinkedBlockingQueue，容量为Integer.MAX_VALUE，最初包含给定集合的元素，按照集合迭代器的遍历顺序添加。

`LinkedBlockingQueue lbq = new LinkedBlockingQueue(Collection c); `

**示例:**
“`java
// Java程序演示
// LinkedBlockingQueue(Collection c) 构造函数

import java.util.concurrent.LinkedBlockingQueue;
import java.util.*;

public class GFG {

public static void main(String[] args)
{

// 创建一个Collection
Vector<Integer> v = new Vector<Integer>();
v.addElement(1);
v.addElement(2);
v.addElement(3);
v.addElement(4);
v.addElement(5);

// 使用 LinkedBlockingQueue(Collection c) 构造函数
// 创建LinkedBlockingQueue对象
LinkedBlockingQueue<Integer> lbq
= new LinkedBlockingQueue<Integer>(v);

// 打印队列
System.out.println("LinkedBlockingQueue:" + lbq);
}
}
“`

**输出**
“`java
LinkedBlockingQueue:[1, 2, 3, 4, 5]
“`

### 基本操作

**1.** **添加元素**

LinkedBlockingQueue的add(E e)方法会在队列未满时将传递给方法的元素插入到队列的末尾。如果队列已满，则此方法将等待空间可用，并在空间可用后将元素插入到LinkedBlockingQueue。
“`java
// Java程序演示将元素添加到
// LinkedBlockingQueue

import java.util.concurrent.LinkedBlockingQueue;

public class AddingElementsExample {

public static void main(String[] args)
{
// 定义LinkedBlockingQueue的容量
int capacity = 15;

// 使用LinkedBlockingQueue(Int initialCapacity)构造函数
// 创建LinkedBlockingQueue对象
LinkedBlockingQueue<Integer> lbq
= new LinkedBlockingQueue<Integer>(capacity);

// 添加数字
lbq.add(1);
lbq.add(2);
lbq.add(3);

// 打印队列
System.out.println("LinkedBlockingQueue:" + lbq);
}
}
“`

**输出**
“`java
LinkedBlockingQueue:[1, 2, 3]
“`

**2\. 移除元素**

LinkedBlockingQueue的remove(Object obj)方法只删除参数中给定的给定对象的一个实例，如果它存在于该LinkedBlockingQueue中。如果该队列包含一个或多个元素e，则它将从中移除一个元素e，条件是obj.equals(e)。如果此方法删除了从LinkedBlockingQueue中删除的元素，则返回true。

“`java
// Java程序演示从LinkedBlockingQueue中移除元素

import java.util.concurrent.LinkedBlockingQueue;

public class RemovingElementsExample {

    public static void main(String[] args)
    {
        // 定义LinkedBlockingQueue的容量
        int capacity = 15;

        // 创建LinkedBlockingQueue的对象
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(capacity);

        // 添加数字
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);

        // 输出队列
        System.out.println("LinkedBlockingQueue:" + lbq);

        // 移除所有元素
        lbq.clear();

        // 输出队列
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}
“`

**输出结果:**
“`java
LinkedBlockingQueue:[1, 2, 3]
LinkedBlockingQueue:[]
“`

**3\. 迭代**

LinkedBlockingQueue的iterator()方法返回一个迭代器，该迭代器包含与该LinkedBlockingQueue相同的元素，以正确的顺序排列。从此方法返回的元素包含LinkedBlockingQueue的第一个（头部）到最后一个（尾部）的所有元素。返回的迭代器是弱一致性的。
“`java
// Java程序演示迭代LinkedBlockingQueue

import java.util.concurrent.LinkedBlockingQueue;
import java.util.Iterator;

public class IteratingExample {

    public static void main(String[] args)
    {
        // 定义LinkedBlockingQueue的容量
        int capacityOfQueue = 7;

        // 创建LinkedBlockingQueue的对象
        LinkedBlockingQueue<String> linkedQueue
            = new LinkedBlockingQueue<String>(capacityOfQueue);

        // 向LinkedBlockingQueue中添加元素
        linkedQueue.add("John");
        linkedQueue.add("Tom");
        linkedQueue.add("Clark");
        linkedQueue.add("Kat");

        // 使用iterator()方法创建linkedQueue的迭代器
        Iterator<String> listOfNames = linkedQueue.iterator();

        // 输出结果
        System.out.println("list of names:");
        while (listOfNames.hasNext())
            System.out.println(listOfNames.next());
    }
} “`
“`

**输出结果：**
“`java
list of names:
John
Tom
Clark
Kat
“`

**4\. 访问元素**

LinkedBlockingQueue的peek()方法返回LinkedBlockingQueue的头部。它检索LinkedBlockingQueue头部的值，但不将其删除。如果LinkedBlockingQueue为空，则此方法返回null。
“`java
// Java程序演示了访问LinkedBlockingQueue元素的方法

import java.util.concurrent.LinkedBlockingQueue;
public class AccessingElementsExample {

    public static void main(String[] args)
    {
        // 定义LinkedBlockingQueue的容量
        int capacityOfQueue = 7;

        // 创建LinkedBlockingQueue对象
        LinkedBlockingQueue linkedQueue
            = new LinkedBlockingQueue(capacityOfQueue);

        // 向LinkedBlockingQueue中添加元素
        linkedQueue.add(“John”);
        linkedQueue.add(“Tom”);
        linkedQueue.add(“Clark”);
        linkedQueue.add(“Kat”);

        // 使用peek()方法查找linkedQueue的头部
        String head = linkedQueue.peek();

        // 打印结果
        System.out.println(“Queue is ” + linkedQueue);

        // 打印队列头部
        System.out.println(“Head of Queue is ” + head);

        // 移除一个元素
        linkedQueue.remove();

        // 再次获取队列头部
        head = linkedQueue.peek();

        // 打印结果
        System.out.println(“\nRemoving one element from Queue\n”);
        System.out.println(“Queue is ” + linkedQueue);

        // 打印队列头部
        System.out.println(“Head of Queue is ” + head);
    }
}
“`

**输出**
“`java
Queue is [John, Tom, Clark, Kat]
Head of Queue is John

Removing one element from Queue

Queue is [Tom, Clark, Kat]
Head of Queue is Tom
“`

### LinkedBlockingQueue的方法

方法 | 描述
—|—
clear() | 原子地从此队列中移除所有元素。
contains(Object o) | 如果此队列包含指定元素，则返回true。
drainTo(Collection c) | 移除此队列中所有可用的元素，并将它们添加到给定的集合中。
drainTo(Collection c, int maxElements) | 移除此队列中最多给定数量的可用元素，并将它们添加到给定的集合中。
forEach(Consumer action) | 对Iterable中的每个元素执行给定的操作，直到所有元素都已处理完或操作引发异常。
iterator() | 返回按正确顺序排列此队列中的元素的迭代器。
offer(E e) | 如果能在不超过队列容量的情况下立即这样做，则将指定元素插入此队列的末尾，并在成功时返回true，如果此队列已满则返回false。
offer(E e, long timeout, TimeUnit unit) | 将指定元素插入此队列的末尾，在必要时等待指定的等待时间以使空间变得可用。
put(E e) | 将指定元素插入此队列的末尾，如果必要，则等待空间变得可用。
remainingCapacity() | 在没有内存或资源限制的情况下，返回此队列可以理想地（而不会阻塞）接受的附加元素数。
remove(Object o) | 如果存在，则从此队列中移除指定元素的单个实例。
removeAll(Collection c) | 移除此集合中也包含在指定集合中的所有元素（可选操作）。
removeIf(Predicate filter) | 移除满足给定谓词的此集合的所有元素。
retainAll(Collection c) | 仅保留在此集合中包含在指定集合中的元素（可选操作）。
size() | 返回此队列中的元素数。
spliterator() | 返回此队列中的元素的Spliterator。
toArray() | 返回包含此队列中所有元素的数组，按正确顺序。
toArray(T[] a) | 返回包含此队列中所有元素的数组，按正确顺序;返回数组的运行时类型是指定数组的类型。

java.util.AbstractCollection类声明的方法

方法	描述
containsAll(Collection c) \| 如果此集合包含指定集合中的所有元素，则返回true。 isEmpty() \| 如果此集合不包含元素，则返回true。 toString() \| 返回此集合的字符串表示形式。 ### 在java.util.AbstractQueue类中声明的方法方法 \| 描述 —\|— add（E e） \| 如果可以立即执行而不违反容量限制，将指定的元素插入此队列，成功时返回true，并在没有当前可用空间时抛出IllegalStateException。 addAll（Collection c） \| 将指定集合中的所有元素添加到此队列中。 element() \| 检索但不删除此队列的头。 remove() \| 检索并删除此队列的头。 ### 在java.util.concurrent.BlockingQueue接口中声明的方法方法 \| 描述 —\|— add（E e） \| 如果可以立即执行而不违反容量限制，将指定的元素插入此队列，成功时返回true，并在没有当前可用空间时抛出IllegalStateException。 poll（long timeout，TimeUnit unit） \| 检索并删除此队列的头，在必要时等待指定的等待时间，直到有元素可用。 take() \| 检索并删除此队列的头，在必要时等待直到有元素可用。 ### 在java.util.Collection接口中声明的方法方法 \| 描述 —\|— addAll（Collection c） \| 将指定集合中的所有元素添加到此集合中（可选操作）。 containsAll（Collection c）	如果此集合包含指定集合中的所有元素，则返回true。
equals（Object o）	将指定的对象与此集合进行比较以确定是否相等。
hashCode()	返回此集合的哈希码值。
isEmpty()	如果此集合不包含元素，则返回true。
parallelStream()	返回可能并行使用此集合作为其源的流。
stream()	返回具有此集合作为其源的顺序流。
toArray（IntFunction<T[]> generator）	使用提供的生成器函数分配返回的数组，返回包含此集合中所有元素的数组。

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

方法	描述
element()	检索但不删除此队列的头。
peek()	检索但不删除此队列的头，如果此队列为空，则返回null。
poll()	检索并删除该队列的头，如果此队列为空，则返回null。
remove()	检索并删除此队列的头。