Java ConcurrentLinkedQueue用法及代码示例

ConcurrentLinkedQueueJava 中的类是Java集合框架。它属于java.util.concurrent包。它是在 JDK 1.5 中引入的。它用于实现队列借助LinkedList同时。它是一个无界的 线程安全Queue 的实现，以 FIFO(先进先出)方式在队列尾部插入元素。当无界队列在多个线程之间共享时可以使用它。该类不允许空元素。迭代器是弱一致的。这个类及其迭代器实现了所有可选方法队列和迭代器接口。
类层次结构：

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

ConcurrentLinkedQueue in Java

声明：

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<E> c)：该构造函数用于构造一个队列，并将 Collection 的元素作为参数传递。

ConcurrentLinkedQueue<E> clq = new ConcurrentLinkedQueue<E>(Collection<E> c);

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

示例 1：

Java


// 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  ConcurrentLinkedQueue
        System.out.println("ConcurrentLinkedQueue: "
                           + clq);
        // Create a ConcurrentLinkedQueue
        // using ConcurrentLinkedQueue(Collection c) 
        // constructor
        ConcurrentLinkedQueue<Integer>
            clq1 = new ConcurrentLinkedQueue<Integer>(clq);
        // Displaying the existing  ConcurrentLinkedQueue
        System.out.println("ConcurrentLinkedQueue1: "
                           + clq1);
    }
}

输出：

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

示例 2：

Java


// 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

Basic Operations

1. 添加元素

添加元素ConcurrentLinkedQueue提供了两种方法。

add() 它将插入元素，并作为参数传递到此 ConcurrentLinkedQueue 的尾部。如果插入成功，该方法返回 True。 ConcurrentLinkedQueue 是无界的，因此此方法永远不会抛出 IllegalStateException 或返回 false。
addAll() 它插入 Collection 的所有元素，并作为参数传递到 ConcurrentLinkedQueue 的末尾。元素的插入顺序与集合迭代器返回的顺序相同。

Java


// 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()ConcurrentLinkedQueue 的方法用于删除指定元素的单个实例(如果存在)。它删除一个元素e使得o.等于(e)。如果 ConcurrentLinkedQueue 包含指定元素，则返回 true，否则返回 false。

Java


// 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 相同元素的迭代器。从此方法返回的元素包含按从第一个(头)到最后一个(尾)的顺序排列的元素。返回的迭代器是弱一致的。

Java


// 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()和Queue element()提供的方法队列用于访问 ConcurrentLinkedQueue 的元素。

element() 方法不同于peek()方法只是如果该队列为空，它会抛出异常。

Java


// 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的方法

METHOD	DESCRIPTION
add(E e)	将指定元素插入此队列的尾部。
addAll(集合 <? 扩展 E> c)	将指定集合中的所有元素按照指定集合的迭代器返回的顺序追加到此队列的末尾。
contains(Object o)	如果此队列包含指定元素，则返回 true。
forEach(消费者<? super E> 操作)	对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常。
isEmpty()	如果此队列不包含元素，则返回 true。
iterator()	按正确的顺序返回此队列中元素的迭代器。
offer(E e)	将指定元素插入此队列的尾部。
remove(Object o)	从此队列中删除指定元素的单个实例(如果存在)。
移除全部(集合<?> c)	删除指定集合中也包含的所有该集合的元素(可选操作)。
removeIf(Predicate<? super E> 过滤器)	删除此集合中满足给定谓词的所有元素。
keepAll(集合<?> c)	仅保留此集合中包含在指定集合中的元素(可选操作)。
size()	返回此队列中的元素数量。
spliterator()	返回此队列中元素的Spliterator。
ConcurrentLinkedQueue toArray()	返回一个数组，其中包含此队列中的所有元素(按正确的顺序)。
ConcurrentLinkedQueue toArray()	返回一个数组，其中包含此队列中的所有元素(按正确的顺序)；返回数组的运行时类型是指定数组的运行时类型。

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

METHOD	DESCRIPTION
AbstractQueue clear()	从此队列中删除所有元素。
AbstractQueue element()	检索但不删除此队列的头部。
AbstractQueue remove()	检索并删除此队列的头部。

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

METHOD	DESCRIPTION
AbstractCollection containsAll()	如果此集合包含指定集合中的所有元素，则返回 true。
AbstractCollection toString()	返回此集合的字符串表示形式。

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

METHOD	DESCRIPTION
Collection clear()	从此集合中删除所有元素(可选操作)。
containsAll(集合<?> c)	如果此集合包含指定集合中的所有元素，则返回 true。
equals(Object o)	比较指定对象与此集合是否相等。
hashCode()	返回此集合的哈希码值。
parallelStream()	返回一个可能并行的 Stream 并以此集合作为其源。
stream()	返回以此集合作为源的顺序 Stream。
toArray(IntFunction<T[]> 生成器)	返回一个包含此集合中所有元素的数组，使用提供的生成器函数分配返回的数组。

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

METHOD	DESCRIPTION
Queue element()	检索但不删除此队列的头部。
Queue peek()	检索但不删除此队列的头部，如果此队列为空，则返回 null。
Queue poll()	检索并删除此队列的头部，如果此队列为空，则返回 null。
Queue remove()	检索并删除此队列的头部。

参考： https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentLinkedQueue.html

相关用法

注：本文由纯净天空筛选整理自RishabhPrabhu大神的英文原创作品 ConcurrentLinkedQueue in Java with Examples。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。