ConcurrentLinkedQueue en Java con ejemplos

La clase ConcurrentLinkedQueue en Java es parte de Java Collection Framework . Pertenece al paquete java.util.concurrent . Fue introducido en JDK 1.5. Se utiliza para implementar Queue con la ayuda de LinkedList al mismo tiempo. Es una implementación ilimitada segura para subprocesos de Queue que inserta elementos en la cola de la cola en forma FIFO (primero en entrar, primero en salir). Se puede usar cuando una cola ilimitada se comparte entre muchos subprocesos. Esta clase no permite elementos nulos. Los iteradores son débilmente consistentes. Esta clase y su iterador implementan todos los métodos opcionales de las interfaces Queue e Iterator .
Jerarquía de clases: 

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

Declaración: 

clase pública ConcurrentLinkedQueue<E> extiende AbstractCollection<E> implementa Queue<E>, Serializable 
 

Aquí, E es el tipo de elementos que mantiene esta colección.

Constructores de ConcurrentLinkedQueue

Para construir una ConcurrentLinkedQueue, debemos importarla desde java.util.ConcurrentLinkedQueue .
 

1. ConcurrentLinkedQueue() : este constructor se usa para construir una cola vacía.

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

2. ConcurrentLinkedQueue(Collection<E> c) : este constructor se utiliza para construir una cola con los elementos de la colección pasados ​​como parámetro.

ConcurrentLinkedQueue<E> clq = new ConcurrentLinkedQueue<E>(Colección<E> c);

A continuación se muestra un programa de ejemplo para ilustrar ConcurrentLinkedQueue en Java: 

Ejemplo 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]

Ejemplo 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

Operaciones básicas

1. Agregar elementos

Para agregar elementos, ConcurrentLinkedQueue proporciona dos métodos.

• add() Inserta el elemento, pasado como parámetro al final de esta ConcurrentLinkedQueue. Este método devuelve True si la inserción se realiza correctamente. ConcurrentLinkedQueue no tiene límites, por lo que este método nunca generará IllegalStateException ni devolverá false.
• addAll() Inserta todos los elementos de la Colección, pasados ​​como parámetro al final de una ConcurrentLinkedQueue. La inserción del elemento está en el mismo orden en que lo devuelve el iterador de la colección.

// 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. Eliminación de elementos

El método remove(Object o) de ConcurrentLinkedQueue se usa para eliminar una sola instancia del elemento especificado si está presente. Elimina un elemento e tal que o.equals(e). Devuelve verdadero si esta ConcurrentLinkedQueue contenía el elemento especificado; de lo contrario, devolverá falso.

// 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. Elementos iterativos 

El método iterator() de ConcurrentLinkedQueue se usa para devolver un iterador de los mismos elementos que este ConcurrentLinkedQueue en una secuencia adecuada. Los elementos devueltos por este método contienen elementos en orden desde el primero (cabeza) hasta el último (cola). El iterador devuelto es débilmente coherente.

// 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. Elementos de acceso

Los métodos peek() y element() proporcionados por Queue se utilizan para acceder a los elementos de ConcurrentLinkedQueue.

El método element() difiere del método peek() solo en que arroja una excepción si esta cola está vacía.

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

Métodos de ConcurrentLinkedQueue

Métodos declarados en la clase java.util.AbstractQueue

Métodos declarados en la clase java.util.AbstractCollection

Métodos declarados en la interfaz java.util.Collection

Métodos declarados en la interfaz java.util.Queue

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