Java LinkedBlockingDeque与实例

Java中的 LinkedBlockingDeque 类是Java集合框架的一部分。它是在JDK 1.6中引入的，属于 java.util.concurrent 包。它是一个Deque（双端队列），如果一个线程试图在Deque为空时从其中取出元素，它就会阻塞该线程。它实现了BlockingDeque，并提供了一个基于链接节点的可选约束功能。这种可选的约束性是通过在构造函数中传递所需的大小来实现的，有助于防止内存的浪费。当未指定时，容量默认为 Integer.MAX_VALUE。 该类及其迭代器实现了 Collection 和 Iterator 接口的所有可选的方法。LinkedBlockingDeque提供的实现是 线程安全的 该类中的所有队列方法都是通过内部的ReentrantLock来实现其效果。

LinkedBlockingDeque的层次结构

Java中的LinkedBlockingDeque与实例

它实现了 Serializable 、 **Iterable **、 **Collection **、BlockingDeque、BlockingQueue、Deque、Queue接口，并扩展了AbstractQueue和AbstractCollection类。

声明

public class LinkedBlockingDeque<E> extends AbstractQueue<E> implements BlockingDeque<E>, Serializable

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

Java 构造函数 LinkedBlockingDeque

为了创建一个LinkedBlockingDeque的实例，我们需要从 java.util.concurrent 包中导入它。

1.LinkedBlockingDeque() : 这个构造函数用来构造一个空的deque。在这种情况下，容量被设置为Integer.MAX_VALUE。

LinkedBlockingDeque<E> lbd = new LinkedBlockingDeque<E>()

2.LinkedBlockingDeque(int capacity) : 这个构造函数创建一个具有给定（固定）容量的LinkedBlockingDeque。

LinkedBlockingDeque<E> lbd = new LinkedBlockingDeque<E>(int capacity);

**3.LinkedBlockingDeque(Collection c) **: 这个构造函数用于构造一个以Collection中的元素作为参数的deque。

LinkedBlockingDeque<E> lbd = new LinkedBlockingDeque<E>(Collection<? extends E> c)

下面是一个说明Java中LinkedBlockingDeque的示例程序：

示例1 :

// Java Program Demonstrate LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class LinkedBlockingDequeDemo {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of LinkedBlockingDeque
        // using LinkedBlockingDeque() constructor
        LinkedBlockingDeque<Integer> LBD
            = new LinkedBlockingDeque<Integer>();
 
        // Add numbers to end of LinkedBlockingDeque
        LBD.add(7855642);
        LBD.add(35658786);
        LBD.add(5278367);
        LBD.add(74381793);
 
        // print Dequee
        System.out.println("Linked Blocking Deque1: "
                           + LBD);
        System.out.println("Size of Linked Blocking Deque1: "
                           + LBD.size());
 
        // create object of LinkedBlockingDeque
        // using LinkedBlockingDeque(int capacity) constructor
        LinkedBlockingDeque<Integer> LBD1
            = new LinkedBlockingDeque<Integer>(3);
 
        // Add numbers to end of LinkedBlockingDeque
        LBD1.add(7855642);
        LBD1.add(35658786);
        LBD1.add(5278367);
 
        try {
            // adding the 4th element
            // will throw exception for Deque full
            LBD1.add(74381793);
        }
        catch (Exception e) {
            System.out.println("Exception: " + e);
        }
 
        // print Dequee
        System.out.println("Linked Blocking Deque2: "
                           + LBD1);
        System.out.println("Size of Linked Blocking Deque2: "
                           + LBD1.size());
 
        // create object of LinkedBlockingDeque
        // using LinkedBlockingDeque(Collection c) constructor
        LinkedBlockingDeque<Integer> LBD2
            = new LinkedBlockingDeque<Integer>(LBD1);
 
        // print Dequee
        System.out.println("Linked Blocking Deque3: "
                           + LBD2);
    }
}

输出

Linked Blocking Deque1: [7855642, 35658786, 5278367, 74381793]
Size of Linked Blocking Deque1: 4
Exception: java.lang.IllegalStateException: Deque full
Linked Blocking Deque2: [7855642, 35658786, 5278367]
Size of Linked Blocking Deque2: 3
Linked Blocking Deque3: [7855642, 35658786, 5278367]

例2：

// Java code to illustrate methods of LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class LinkedBlockingDequeDemo {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of LinkedBlockingDeque
        LinkedBlockingDeque<Integer> LBD
            = new LinkedBlockingDeque<Integer>();
 
        // Add numbers to end of LinkedBlockingDeque
        // using add() method
        LBD.add(7855642);
        LBD.add(35658786);
        LBD.add(5278367);
        LBD.add(74381793);
 
        // prints the Deque
        System.out.println("Linked Blocking Deque: "
                           + LBD);
 
        // prints the size of Deque after removal
        // using size() method
        System.out.println("Size of Linked Blocking Deque: "
                           + LBD.size());
 
        // removes the front element and prints it
        // using removeFirst() method
        System.out.println("First element: "
                           + LBD.removeFirst());
 
        // prints the Deque
        System.out.println("Linked Blocking Deque: "
                           + LBD);
 
        // prints the size of Deque after removal
        // using size() method
        System.out.println("Size of Linked Blocking Deque: "
                           + LBD.size());
 
        // Add numbers to end of LinkedBlockingDeque
        // using offer() method
        LBD.offer(20);
 
        // prints the Deque
        System.out.println("Linked Blocking Deque: "
                           + LBD);
 
        // prints the size of Deque after removal
        // using size() method
        System.out.println("Size of Linked Blocking Deque: "
                           + LBD.size());
    }
}

输出

Linked Blocking Deque: [7855642, 35658786, 5278367, 74381793]
Size of Linked Blocking Deque: 4
First element: 7855642
Linked Blocking Deque: [35658786, 5278367, 74381793]
Size of Linked Blocking Deque: 3
Linked Blocking Deque: [35658786, 5278367, 74381793, 20]
Size of Linked Blocking Deque: 4

基本操作

1.添加元素

LinkedBlockingDeque提供了各种方法来添加或插入两端的元素。它们是add(E e), addAll(Collection c), addFirst(E e), addLast(E e)等。

// Java Program Demonstrate adding
// elements to LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class AddingElementsExample {
    public static void main(String[] args)
        throws IllegalStateException
    {
 
        // create object of LinkedBlockingDeque
        LinkedBlockingDeque<Integer> lbd
            = new LinkedBlockingDeque<Integer>();
 
        // Add number to end of LinkedBlockingDeque
        lbd.add(7855642);
 
        // Add integer at the head or front
        lbd.addFirst(35658786);
 
        // Add integer at the tail or end
        lbd.addLast(5278367);
 
        // print Deque
        System.out.println("Linked Blocking Deque: " + lbd);
           
          // Create object of ArrayList collection
        ArrayList<Integer> ArrLis
            = new ArrayList<Integer>();
   
        // Add number to ArrayList
        ArrLis.add(55);
        ArrLis.add(66);
        ArrLis.add(77);
        ArrLis.add(88);
   
        // Print ArrayList
        System.out.println("ArrayList: " + ArrLis);
   
        // Function addAll() adds all the elements of
        // ArrayList to Deque
        lbd.addAll(ArrLis);
   
        // Print deque
        System.out.println("Linked Blocking Deque: " + lbd);
    }
}

输出

Linked Blocking Deque: [35658786, 7855642, 5278367]
ArrayList: [55, 66, 77, 88]
Linked Blocking Deque: [35658786, 7855642, 5278367, 55, 66, 77, 88]

2.删除元素

LinkedBlockingDeque提供了各种方法来删除或删除两端的元素。它们是remove()、removeFirst()、removeLast()等。

// Java Program Demonstrate removing
// elements of LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class RemovingElementsExample {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of LinkedBlockingDeque
        LinkedBlockingDeque<Integer> lbd
            = new LinkedBlockingDeque<Integer>();
 
        // Add numbers to end of LinkedBlockingDeque
        lbd.add(7855642);
        lbd.add(35658786);
        lbd.add(5278367);
        lbd.add(74381793);
        lbd.add(12345566);
 
        // print Dequeue
        System.out.println("Linked Blocking Deque: " + lbd);
 
        // removes the front element
        lbd.remove();
 
        // print the modified deque
        System.out.println("Linked Blocking Deque: " + lbd);
 
        // removes the front element
        lbd.removeFirst();
 
        // print the modified deque
        System.out.println("Linked Blocking Deque: " + lbd);
 
        // removes the last element
        lbd.removeLast();
 
        // print the modified deque
        System.out.println("Linked Blocking Deque: " + lbd);
    }
}

输出

Linked Blocking Deque: [7855642, 35658786, 5278367, 74381793, 12345566]
Linked Blocking Deque: [35658786, 5278367, 74381793, 12345566]
Linked Blocking Deque: [5278367, 74381793, 12345566]
Linked Blocking Deque: [5278367, 74381793]

3.迭代

LinkedBlockingDeque的iterator()方法以适当的顺序返回该deque中元素的迭代器。这些元素将按照从头（head）到尾（tail）的顺序返回。返回的迭代器是一个 “弱一致 “的迭代器。

// Java Program Demonstrate iterating
// over LinkedBlockingDeque
 
import java.util.concurrent.LinkedBlockingDeque;
import java.util.*;
 
public class IteratingExample {
    public static void main(String[] args)
 
    {
 
        // create object of LinkedBlockingDeque
        LinkedBlockingDeque<Integer> LBD
            = new LinkedBlockingDeque<Integer>();
 
        // Add numbers to front of LinkedBlockingDeque
        LBD.addFirst(7855642);
        LBD.addFirst(35658786);
        LBD.addFirst(5278367);
        LBD.addFirst(74381793);
 
        // Call iterator() method of LinkedBlockingDeque
        Iterator iteratorVals = LBD.iterator();
 
        // Print elements of iterator
        // created from PriorityBlockingQueue
        System.out.println("The iterator values"
            + " of LinkedBlockingDeque are:");
 
        // prints the elements using an iterator
        while (iteratorVals.hasNext()) {
            System.out.println(iteratorVals.next());
        }
    }
}

输出

The iterator values of LinkedBlockingDeque are:
74381793
5278367
35658786
7855642

LinkedBlockingDeque的方法

方法	描述
add(E e)	在这个deque的末尾插入指定的元素，除非它违反了容量限制。
addAll(Collection c) \| 按照指定集合的迭代器返回的顺序，将指定集合中的所有元素添加到这个deque的最后。 addFirst(E e) \| 如果可以在不违反容量限制的情况下立即插入指定的元素到这个deque的前面，如果当前没有可用空间，则抛出IllegalStateException。 addLast(E e) \| 如果可以在不违反容量限制的情况下立即插入指定的元素到这个deque的末尾，如果当前没有可用空间，则抛出IllegalStateException。 clear() \| 原子化地删除这个deque中的所有元素。 contains(Object o) \| 如果这个deque包含指定的元素，返回true。 descendingIterator() \| 以相反的顺序返回这个deque中的元素的迭代器。 drainTo(Collection c) \| 从这个队列中移除所有可用的元素，并将它们添加到指定的集合中。 drainTo(Collection c, int maxElements) \| 从这个队列中最多移除指定数量的可用元素，并将它们添加到给定的集合中。 element() \| 检索，但不删除这个deque所代表的队列的头部。 forEach(Consumer action) \| 对Iterable的每个元素执行给定的动作，直到所有的元素都被处理完，或者该动作抛出一个异常。 getFirst() \| 检索，但不删除，这个德克的第一个元素。 getLast() \| 读取但不删除这个deque的最后一个元素。 iterator() \| 返回这个deque中的元素的迭代器，并按照适当的顺序排列。 offer(E e) \| 如果可以在不违反容量限制的情况下立即插入指定的元素到这个deque所代表的队列中（换句话说，在这个deque的尾部），成功后返回true，如果当前没有可用空间，则返回false。 offer(E e, long timeout, TimeUnit unit) \| 将指定的元素插入到这个deque所代表的队列中（换句话说，在这个deque的尾部），如果有必要，可以等待到指定的等待时间，以获得空间。 offerFirst(E e) \| 如果可以在不违反容量限制的情况下立即插入指定的元素到这个deque的前面，成功后返回true，如果当前没有可用空间则返回false。 offerFirst(E e, long timeout, TimeUnit unit) \| 在这个deque的前面插入指定的元素，如果有必要的话，在指定的等待时间内等待空间的出现。 offerLast(E e) \| 如果可以在不违反容量限制的情况下立即插入指定的元素，则在deque的最后插入，成功后返回true，如果当前没有可用空间则返回false。 offerLast(E e, long timeout, TimeUnit unit) \| 在这个deque的末尾插入指定的元素，如果有必要，可以等待到指定的等待时间，以获得可用空间。 pop() \| 从这个deque所代表的堆栈中弹出一个元素。 push(E e) \| 如果可以在不违反容量限制的情况下立即将一个元素推到这个deque所代表的堆栈上（换句话说，在这个deque的头部），如果目前没有可用的空间，则抛出IllegalStateException。 put(E e) \| 将指定的元素插入到这个deque所代表的队列中（换句话说，在这个deque的尾部），如果有必要的话，等待空间变得可用。 putFirst(E e) \| 将指定的元素插入这个deque的前面，如果需要的话，等待空间的出现。 putLast(E e) \| 将指定的元素插入到这个deque的末尾，如果需要的话，等待空间的出现。 remainingCapacity() \| 返回这个deque在理想情况下（在没有内存或资源限制的情况下）可以接受的额外元素的数量，而不会出现阻塞。 remove() \| 检索并删除这个deque所代表的队列的头部。 remove(Object o) \| 从这个deque中移除第一个出现的指定元素。 removeAll(Collection c)	移除这个集合中也包含在指定集合中的所有元素（可选操作）。
removeFirst()	检索并删除这个deque中的第一个元素。
removeIf(Predicate filter) \| 删除这个集合中满足给定谓词的所有元素。 removeLast() \| 检索并删除这个deque中的最后一个元素。 retainAll(Collection c)	只保留此集合中包含在指定集合中的元素（可选操作）。
size()	返回这个deque中元素的数量。
spliterator()	返回这个deque中的元素的一个Spliterator。
toArray()	返回一个包含所有deque元素的数组，按照正确的顺序（从第一个元素到最后一个元素）。
toArray(T[] a)	返回一个包含这个deque中所有元素的数组，并以适当的顺序排列；返回的数组的运行时类型是指定数组的类型。

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

方法	描述
containsAll(Collection c) \| 如果这个集合包含了指定集合中的所有元素，返回true。 isEmpty() \| 如果这个集合不包含任何元素，则返回true。 toString() \| 返回这个集合的一个字符串表示。 ### java.util.concurrent.BlockingDeque接口中声明的方法方法 \| 描述 —\|— peek() \| 检索但不删除这个deque所代表的队列的头部（换句话说，这个deque的第一个元素），如果这个deque为空，则返回null。 poll() \| 检索并删除这个deque所代表的队列的头部（换句话说，这个deque的第一个元素），如果这个deque是空的，则返回null。 poll(long timeout, TimeUnit unit) \| 检索并删除这个deque所代表的队列的头部（换句话说，这个deque的第一个元素），如果有必要，可以等待指定的等待时间，让一个元素变得可用。 pollFirst(long timeout, TimeUnit unit) \| 检索并删除这个deque的第一个元素，如果有必要的话，要等待到指定的等待时间才能有一个元素可用。 pollLast(long timeout, TimeUnit unit) \| 检索并删除这个deque的最后一个元素，如果需要的话，要等待到指定的等待时间，让一个元素变得可用。 removeFirstOccurrence(Object o) \| 从这个deque中删除第一次出现的指定元素。 removeLastOccurrence(Object o) \| 从这个deque中删除最后出现的指定元素。 take() \| 检索并删除这个deque所代表的队列的头部（换句话说，就是这个deque的第一个元素），如果有必要，可以等待，直到有元素可用。 takeFirst() \| 检索并删除这个deque的第一个元素，如果有必要的话，等待一个元素变得可用。 takeLast() \| 检索并删除这个deque中的最后一个元素，如果有必要的话，等待一个元素变得可用。 ### java.util.Collection接口中声明的方法方法 \| 描述 —\|— containsAll(Collection c)	如果这个集合包含指定集合中的所有元素，则返回true。
equals(Object o)	将指定的对象与这个集合进行比较，看是否相等。
hashCode()	返回此集合的哈希代码值。
isEmpty()	如果这个集合不包含任何元素，返回true。
parallelStream()	返回一个以该集合为源的可能的并行流。
stream()	返回一个以这个集合为源的顺序流。
toArray(IntFunction<T[]> generator)	返回一个包含此集合中所有元素的数组，使用提供的生成器函数来分配返回的数组。

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

方法	描述
peekFirst()	检索但不删除此deque的第一个元素，如果此deque为空，则返回null。
peekLast()	检索但不删除这个deque的最后一个元素，如果这个deque是空的，则返回null。
pollFirst()	检索并删除这个deque的第一个元素，如果这个deque是空的，则返回null。
pollLast()	检索并删除这个deque的最后一个元素，如果这个deque是空的，则返回null。