Java LinkedBlockingQueue

LinkedBlockingQueue 是一个基于链接节点的可选择约束的阻塞队列。这意味着，如果LinkedBlockingQueue的容量给定，那么LinkedBlockingQueue可以是有界的，否则LinkedBlockingQueue将是无界的。容量可以作为参数给到LinkedBlockingQueue的构造函数。这个队列以 FIFO（先进先出） 的方式排列元素。这意味着这个队列的头部是这个队列中存在的元素中最老的元素。这个队列的尾部是这个队列的元素中最新的元素。新插入的元素总是插在队列的尾部，而队列的检索操作在队列的头部获得元素。链接队列通常比基于数组的队列有更高的吞吐量，但在大多数并发应用中的性能不那么可预测。

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

LinkedBlockingQueue的层次结构

Java中的链接阻塞队列（LinkedBlockingQueue）类

LinkedBlockingQueue扩展了AbstractQueue并实现了 Serializable , **Iterable **, **Collection **, BlockingQueue , Queue接口。

声明

public class **LinkedBlockingQueue **extends AbstractQueue implements BlockingQueue, Serializable

E - 这个集合中持有的元素的类型。

LinkedBlockingQueue的构造函数。

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

1.LinkedBlockingQueue() : 创建一个LinkedBlockingQueue，其容量为Integer.MAX_VALUE。

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 program to demonstrate
// LinkedBlockingQueue(int initialCapacity) constructor
  
import java.util.concurrent.LinkedBlockingQueue;
  
public class GFG {
  
    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacity = 15;
  
        // create object of LinkedBlockingQueue
        // using LinkedBlockingQueue(int initialCapacity)
        // constructor
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(capacity);
  
        // add  numbers
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);
  
        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}

输出

LinkedBlockingQueue:[1, 2, 3]

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

`LinkedBlockingQueue lbq = new LinkedBlockingQueue(Collection c)`

**例子**
“`java
// Java program to demonstrate
// LinkedBlockingQueue(Collection c) constructor

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

public class GFG {

    public static void main(String[] args)
    {

        // Creating a Collection
        Vector<Integer> v = new Vector<Integer>();
        v.addElement(1);
        v.addElement(2);
        v.addElement(3);
        v.addElement(4);
        v.addElement(5);

        // create object of LinkedBlockingQueue
        // using LinkedBlockingQueue(Collection c)
        // constructor
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(v);

        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}
“`

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

### 基本操作

**1. 添加元素**

如果队列没有满，LinkedBlockingQueue的add(E e)方法将作为参数传递给方法的元素插入这个LinkedBlockingQueue的尾部。如果队列是满的，那么这个方法将等待空间变得可用，在空间可用之后，它将元素插入到LinkedBlockingQueue中。
“`java
// Java Program to Demonstrate adding
// elements to the LinkedBlockingQueue

import java.util.concurrent.LinkedBlockingQueue;

public class AddingElementsExample {

    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacity = 15;

        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(capacity);

        // add numbers
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);

        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}
“`

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

**2.删除元素**

LinkedBlockingQueue的remove(Object obj)方法只从LinkedBlockingQueue中删除一个作为参数传递的给定Object的实例，如果它存在的话。如果这个队列包含一个或多个元素e的实例，它就会删除一个元素e，即obj.e equals(e)。如果这个队列包含现在从LinkedBlockingQueen中删除的元素，这个方法就会返回true。

“`java
// Java Program to Demonstrate removing
// elements from the LinkedBlockingQueue

import java.util.concurrent.LinkedBlockingQueue;

public class RemovingElementsExample {

    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacity = 15;

        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(capacity);

        // add numbers
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);

        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);

        // remove all the elements
        lbq.clear();

        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}
“`

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

**3.迭代**

LinkedBlockingQueue的iterator()方法返回一个与此LinkedBlockingQueue相同的元素的迭代器，并且是以适当的顺序。这个方法返回的元素包含了所有的元素，顺序是LinkedBlockingQueue的 **第一个（head）** 到 **最后一个（tail）** 。返回的迭代器是弱一致性的。
“`java
// Java Program Demonstrate iterating
// over LinkedBlockingQueue

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

public class IteratingExample {

    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacityOfQueue = 7;

        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<String> linkedQueue
            = new LinkedBlockingQueue<String>(capacityOfQueue);

        // Add element to LinkedBlockingQueue
        linkedQueue.add("John");
        linkedQueue.add("Tom");
        linkedQueue.add("Clark");
        linkedQueue.add("Kat");

        // create Iterator of linkedQueue using iterator() method
        Iterator<String> listOfNames = linkedQueue.iterator();

        // print result
        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 Program Demonstrate accessing
// elements of LinkedBlockingQueue

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

    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacityOfQueue = 7;

        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<String> linkedQueue
            = new LinkedBlockingQueue<String>(capacityOfQueue);

        // Add element to LinkedBlockingQueue
        linkedQueue.add("John");
        linkedQueue.add("Tom");
        linkedQueue.add("Clark");
        linkedQueue.add("Kat");

        // find head of linkedQueue using peek() method
        String head = linkedQueue.peek();

        // print result
        System.out.println("Queue is " + linkedQueue);

        // print head of queue
        System.out.println("Head of Queue is " + head);

        // removing one element
        linkedQueue.remove();

        // again get head of queue
        head = linkedQueue.peek();

        // print result
        System.out.println("\nRemoving one element from Queue\n");
        System.out.println("Queue is " + linkedQueue);

        // print head of queue
        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中声明的方法

方法	描述
元素()	检索，但不删除这个队列的头部。
peek()	检索但不删除此队列的头部，如果此队列为空，则返回null。
poll()	检索并删除这个队列的头部，如果这个队列是空的，则返回null。
remove()	检索并删除这个队列的头部。