Java ConcurrentLinkedQueue与实例

Java中的 ConcurrentLinkedQueue 类是Java Collection Framework的一部分。它属于 java.util.concurrent 包。它是在JDK 1.5中引入的。它被用来在LinkedList的帮助下并发地实现队列。它是一个 无界线程安全的 队列实现，以FIFO（先进先出）的方式在队列的尾部插入元素。当一个无界的队列被许多线程共享时，可以使用它。该类不允许出现空元素。迭代器是弱一致性的。该类及其迭代器实现了 Queue 和 Iterator 接口的所有可选方法。

类层次结构 。

java.lang.Object
  ↳ java.util.AbstractCollection<E>
     ↳ java.util.AbstractQueue<E>
        ↳ Class ConcurrentLinkedQueue<E>

Java中的ConcurrentLinkedQueue与实例

声明

public class ConcurrentLinkedQueue<E> extends AbstractCollection<E> implements Queue<E>, Serializable

这里， E 是这个集合所维护的元素的类型。

ConcurrentLinkedQueue的构造函数

为了构造一个ConcurrentLinkedQueue，我们需要从 java.util.ConcurrentLinkedQueue 中导入它。

1.ConcurrentLinkedQueue() : 这个构造函数用来构造一个空队列。

ConcurrentLinkedQueue<E> clq = new ConcurrentLinkedQueue<E>（）

**2.ConcurrentLinkedQueue(Collection c) **: 这个构造函数用来构造一个队列，参数是Collection的元素。

ConcurrentLinkedQueue<E> clq = new ConcurrentLinkedQueue<E>（Collection<E> c）

下面是一个示例程序，说明Java中的ConcurrentLinkedQueue。

例1：

// Java program to demonstrate ConcurrentLinkedQueue
 
import java.util.concurrent.*;
 
class ConcurrentLinkedQueueDemo {
   
    public static void main(String[] args)
    {
        // Create a ConcurrentLinkedQueue
        // using ConcurrentLinkedQueue() constructor
        ConcurrentLinkedQueue<Integer>
            clq = new ConcurrentLinkedQueue<Integer>();
 
        clq.add(12);
        clq.add(70);
        clq.add(1009);
        clq.add(475);
 
        // Displaying the existing LinkedQueue
        System.out.println("ConcurrentLinkedQueue: "
                           + clq);
 
        // Create a ConcurrentLinkedQueue
        // using ConcurrentLinkedQueue(Collection c)
        // constructor
        ConcurrentLinkedQueue<Integer>
            clq1 = new ConcurrentLinkedQueue<Integer>(clq);
 
        // Displaying the existing LinkedQueue
        System.out.println("ConcurrentLinkedQueue1: "
                           + clq1);
    }
}

输出

ConcurrentLinkedQueue: [12, 70, 1009, 475]
ConcurrentLinkedQueue1: [12, 70, 1009, 475]

例2：

// Java code to illustrate
// methods of ConcurrentLinkedQueue
 
import java.util.concurrent.*;
 
class ConcurrentLinkedQueueDemo {
   
    public static void main(String[] args)
    {
 
        // Create a ConcurrentLinkedQueue
        // using ConcurrentLinkedQueue()
          // constructor
        ConcurrentLinkedQueue<Integer>
            clq = new ConcurrentLinkedQueue<Integer>();
 
        clq.add(12);
        clq.add(70);
        clq.add(1009);
        clq.add(475);
 
        // Displaying the existing ConcurrentLinkedQueue
        System.out.println("ConcurrentLinkedQueue: "
                           + clq);
 
        // Displaying the first element
        // using peek() method
        System.out.println("First Element is: "
                           + clq.peek());
 
        // Remove and display the first element
        // using poll() method
        System.out.println("Head Element is: "
                           + clq.poll());
 
        // Displaying the existing ConcurrentLinkedQueue
        System.out.println("ConcurrentLinkedQueue: "
                           + clq);
 
        // Get the size using size() method
        System.out.println("Size: "
                           + clq.size());
    }
}

输出

ConcurrentLinkedQueue: [12, 70, 1009, 475]
First Element is: 12
Head Element is: 12
ConcurrentLinkedQueue: [70, 1009, 475]
Size: 3

基本操作

1.添加元素

为了添加元素，ConcurrentLinkedQueue提供了两个方法。

add() 它插入元素，作为参数传递到这个并发连接队列的尾部。如果插入成功，该方法返回True。ConcurrentLinkedQueue是无界的，所以这个方法不会抛出IllegalStateException或返回false。
addAll() 它插入集合的所有元素，作为参数传递到ConcurrentLinkedQueue的末端。插入元素的顺序与集合的迭代器返回的顺序相同。

// Java Program Demonstrate adding
// elements to ConcurrentLinkedQueue
 
import java.util.concurrent.*;
import java.util.*;
 
public class AddingElementsExample {
   
    public static void main(String[] args)
    {
 
        // Create an instance of ConcurrentLinkedQueue
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();
 
        // Add String to queue using add method
        queue.add("Kolkata");
        queue.add("Patna");
        queue.add("Delhi");
        queue.add("Jammu");
 
        // Displaying the existing ConcurrentLinkedQueue
        System.out.println("ConcurrentLinkedQueue: " + queue);
 
        // create a ArrayList of Strings
        ArrayList<String> arraylist = new ArrayList<String>();
   
        // add String to ArrayList
        arraylist.add("Sanjeet");
        arraylist.add("Rabi");
        arraylist.add("Debasis");
        arraylist.add("Raunak");
        arraylist.add("Mahesh");
 
        // Displaying the existing Collection
        System.out.println("Collection to be added: " + arraylist);
 
        // apply addAll() method and passed
        // the arraylist as parameter
        boolean response = queue.addAll(arraylist);
 
        // Displaying the existing ConcurrentLinkedQueue
        System.out.println("Collection added: " + response);
 
        // Displaying the existing ConcurrentLinkedQueue
        System.out.println("ConcurrentLinkedQueue: " + queue);
    }
}

输出

ConcurrentLinkedQueue: [Kolkata, Patna, Delhi, Jammu]
Collection to be added: [Sanjeet, Rabi, Debasis, Raunak, Mahesh]
Collection added: true
ConcurrentLinkedQueue: [Kolkata, Patna, Delhi, Jammu, Sanjeet, Rabi, Debasis, Raunak, Mahesh]

2.移除元素

ConcurrentLinkedQueue的remove(Object o)方法是用来移除指定元素的单个实例的，如果它是存在的。它删除了一个元素 e ，使得o.e equals(e)。如果这个ConcurrentLinkedQueue包含指定的元素，它将返回true，否则它将返回false。

// Java Program Demonstrate removing
// elements from ConcurrentLinkedQueue
 
import java.util.concurrent.*;
 
public class RemovingElementsExample {
   
    public static void main(String[] args)
    {
 
        // Create an instance of ConcurrentLinkedQueue
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<Integer>();
 
        // Add Numbers to queue using add(e) method
        queue.add(4353);
        queue.add(7824);
        queue.add(78249);
        queue.add(8724);
 
        // Displaying the existing ConcurrentLinkedQueue
        System.out.println("ConcurrentLinkedQueue: " + queue);
 
        // apply remove() for Number 78249
        boolean response = queue.remove(78249);
 
        // print results
        System.out.println("Removing Number 78249 successful: " + response);
 
        // Displaying the existing ConcurrentLinkedQueue
        System.out.println("Updated ConcurrentLinkedQueue: " + queue);
    }
}

输出

ConcurrentLinkedQueue: [4353, 7824, 78249, 8724]
Removing Number 78249 successful: true
Updated ConcurrentLinkedQueue: [4353, 7824, 8724]

3.迭代元素

ConcurrentLinkedQueue的iterator()方法用来返回一个与该ConcurrentLinkedQueue相同的元素的迭代器，其顺序是正确的。该方法返回的元素按照从头（head）到尾（tail）的顺序。返回的迭代器是弱一致性的。

// Java Program Demonstrate Iterating
// over ConcurrentLinkedQueue
 
import java.util.concurrent.*;
import java.util.*;
 
public class TraversingExample {
   
    public static void main(String[] args)
    {
        // Create an instance of ConcurrentLinkedQueue
        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();
 
        // Add String to queue using add(e) method
        queue.add("Aman");
        queue.add("Amar");
        queue.add("Sanjeet");
        queue.add("Rabi");
 
        // Displaying the existing ConcurrentLinkedQueue
        System.out.println("ConcurrentLinkedQueue : " + queue);
 
        // Call iterator() method
        Iterator iterator = queue.iterator();
 
        // Print elements of iterator
        System.out.println("\nThe String Values of iterator are:");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

输出

ConcurrentLinkedQueue : [Aman, Amar, Sanjeet, Rabi]

The String Values of iterator are:
Aman
Amar
Sanjeet
Rabi

4.访问元素

Queue 提供的 peek() 和 element() 方法用于访问 ConcurrentLinkedQueue 的元素。

element()方法与peek()方法的不同之处在于，如果这个队列是空的，它会抛出一个异常。

// Java Program Demonstrate accessing
// elements of ConcurrentLinkedQueue
 
import java.util.*;
import java.util.concurrent.*;
 
public class AccessingElementsExample {
   
    public static void main(String[] args) throws IllegalStateException
    {
        // Create an instance of ConcurrentLinkedQueue
        ConcurrentLinkedQueue<Integer> Q = new ConcurrentLinkedQueue<>();
 
        // Add numbers to end of Queue
        Q.add(7855642);
        Q.add(35658786);
        Q.add(5278367);
        Q.add(74381793);
 
        // print queue
        System.out.println("Queue: " + Q);
 
        // print head
        System.out.println("Queue's head: " + Q.element());
 
        // print head
        System.out.println("Queue's head: " + Q.peek());
    }
}

输出

Queue: [7855642, 35658786, 5278367, 74381793]
Queue's head: 7855642
Queue's head: 7855642

ConcurrentLinkedQueue的方法

方法	描述
add(E e)	在这个队列的尾部插入指定的元素。
addAll(Collection c) \| 按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到这个队列的尾部。包含(Object o) \| 如果这个队列包含指定的元素，返回true。 forEach(Consumer action) \| 对Iterable的每个元素执行给定的动作，直到所有的元素都被处理完，或者该动作抛出一个异常。 isEmpty() \| 如果这个队列不包含任何元素，返回true。 iterator() \| 以适当的顺序返回这个队列中的元素的迭代器。 offer(E e) \| 在这个队列的尾部插入指定的元素。 remove(Object o) \| 从这个队列中删除指定元素的一个实例，如果它存在的话。 removeAll(Collection c)	删除这个集合中也包含在指定集合中的所有元素（可选操作）。
removeIf(Predicate filter) \| 删除此集合中满足给定谓词的所有元素。 retainAll(Collection c)	只保留此集合中包含在指定集合中的元素（可选操作）。
size()	返回这个队列中元素的数量。
spliterator()	返回这个队列中的元素的Spliterator。
toArray()	返回一个包含该队列中所有元素的数组，并按适当的顺序排列。
toArray(T[] a)	返回一个包含该队列中所有元素的数组，并以适当的顺序排列；返回的数组的运行时类型是指定数组的类型。

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

方法	描述
清除()	移除队列中的所有元素。
element()	检索，但不删除这个队列的头部。
remove()	检索并删除此队列的头部。

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

方法	描述
containsAll(Collection c) \| 如果这个集合包含指定集合中的所有元素，则返回true。 toString() \| 返回这个集合的一个字符串表示。 ### java.util.Collection接口中声明的方法方法 \| 描述 —\|— 清除() \| 移除这个集合中的所有元素（可选操作）。 containsAll(Collection c)	如果这个集合包含了指定集合中的所有元素，返回true。
equals(Object o)	将指定的对象与这个集合进行比较，看是否相等。
哈希代码()	返回此集合的哈希代码值。
parallelStream()	返回一个以该集合为源的可能的并行流。
stream()	返回一个以该集合为源的顺序流。
toArray(IntFunction<T[]> generator)	返回一个包含此集合中所有元素的数组，使用提供的生成器函数来分配返回的数组。

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

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