LinkedTransferQueue en Java con ejemplos

La clase LinkedTransferQueue en Java es parte de Java Collection Framework . Fue introducido en JDK 1.7 y pertenece al paquete java.util.concurrent . Implementa TransferQueuey proporciona una funcionalidad ilimitada basada en Nodes vinculados. Los elementos en LinkedTransferQueue están ordenados en orden FIFO, con la cabeza apuntando al elemento que ha estado en la cola durante más tiempo y la cola apuntando al elemento que ha estado en la cola durante menos tiempo. Debido a su naturaleza asíncrona, size() atraviesa toda la colección, por lo que no es una operación de tiempo O(1). También puede dar un tamaño inexacto si esta colección se modifica durante el recorrido. No se garantiza que las operaciones masivas como addAll, removeAll, retainAll, containsAll, equals y toArray se realicen de forma atómica. Por ejemplo, un iterador que opera simultáneamente con una operación addAll podría observar solo algunos de los elementos agregados.

LinkedTransferQueue ha utilizado aplicaciones de paso de mensajes. Hay dos aspectos en los que el mensaje se pasará del hilo del productor al hilo del consumidor. 

  1. put(E e) : este método se usa si el productor quiere poner elementos en cola sin esperar a un consumidor. Sin embargo, espera hasta que el espacio esté disponible si la cola está llena.
  2. transfer(E e) : este método generalmente se usa para transferir un elemento a un subproceso que está esperando recibirlo, si no hay un subproceso en espera, esperará hasta que un subproceso llegue al estado de espera tan pronto como llegue el subproceso en espera. el elemento será transferido a él.

La jerarquía de LinkedTransferQueue

Hierarchy of LinkedTransferQueue in Java

Implementa interfaces Serializable , Iterable<E> , Collection<E> , BlockingQueue<E> , TransferQueue<E> , Queue<E> y extiende las clases AbstractQueue<E> y AbstractCollection<E> .

 Declaración: 

clase pública LinkedTransferQueue<E> extiende AbstractQueue<E> implementa TransferQueue<E>, Serializable

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

Constructores de LinkedTransferQueue

Para crear una instancia de LinkedTransferQueue, debemos importarla desde el paquete java.util.concurrent .
 

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

LinkedTransferQueue<E> ltq = new LinkedTransferQueue<E>();

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

LinkedTransferQueue<E> ltq = new LinkedTransferQueue<E>(Colección<E> c);

Ejemplo 1: programa de ejemplo para ilustrar LinkedTransferQueue en Java

Java

// Java Program Demonstrate LinkedTransferQueue
  
import java.util.concurrent.LinkedTransferQueue;
import java.util.*;
  
public class LinkedTransferQueueDemo {
    public static void main(String[] args)
        throws InterruptedException
    {
        // create object of LinkedTransferQueue
        // using LinkedTransferQueue() constructor
        LinkedTransferQueue<Integer> LTQ
            = new LinkedTransferQueue<Integer>();
  
        // Add numbers to end of LinkedTransferQueue
        LTQ.add(7855642);
        LTQ.add(35658786);
        LTQ.add(5278367);
        LTQ.add(74381793);
  
        // print Queue
        System.out.println("Linked Transfer Queue1: " + LTQ);
  
        // create object of LinkedTransferQueue
        // using LinkedTransferQueue(Collection c)
        // constructor
        LinkedTransferQueue<Integer> LTQ2
            = new LinkedTransferQueue<Integer>(LTQ);
  
        // print Queue
        System.out.println("Linked Transfer Queue2: " + LTQ2);
    }
}
Producción

Linked Transfer Queue1: [7855642, 35658786, 5278367, 74381793]
Linked Transfer Queue2: [7855642, 35658786, 5278367, 74381793]

Ejemplo 2: 
 

Java

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

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

Operaciones básicas

1. Agregar elementos

LinkedTransferQueue proporciona varios métodos para agregar o insertar elementos. Son add(E e) , put(E e) , offer(E e) , transfer(E e) . Los métodos add, put y offer no se preocupan de que otros subprocesos accedan a la cola o no, mientras que transfer() espera uno o más subprocesos destinatarios.

Java

// Java Program Demonstrate adding
// elements to LinkedTransferQueue
  
import java.util.concurrent.*;
  
class AddingElementsExample {
    public static void main(String[] args)
    {
  
        // Initializing the queue
        LinkedTransferQueue<Integer> queue
            = new LinkedTransferQueue<Integer>();
  
        // Adding elements to this queue
        for (int i = 10; i <= 14; i++)
            queue.add(i);
  
        // Add the element using offer() method
        System.out.println("adding 15 "
            + queue.offer(15, 5, TimeUnit.SECONDS));
  
        // Adding elements to this queue
        for (int i = 16; i <= 20; i++)
            queue.put(i);
  
        // Printing the elements of the queue
        System.out.println(
            "The elements in the queue are:");
        for (Integer i : queue)
            System.out.print(i + " ");
  
        System.out.println();
  
        // create another queue to demonstrate transfer
        // method
        LinkedTransferQueue<String> g
            = new LinkedTransferQueue<String>();
  
        new Thread(new Runnable() {
            public void run()
            {
                try {
                    System.out.println("Transferring"
                                       + " an element");
  
                    // Transfer a String element
                    // using transfer() method
                    g.transfer("is a computer"
                               + " science portal.");
                    System.out.println(
                        "Element "
                        + "transfer is complete");
                }
                catch (InterruptedException e1) {
                    System.out.println(e1);
                }
                catch (NullPointerException e2) {
                    System.out.println(e2);
                }
            }
        })
            .start();
  
        try {
  
            // Get the transferred element
            System.out.println("Geeks for Geeks "
                               + g.take());
        }
        catch (Exception e) {
            System.out.println(e);
        }
    }
}
Producción

adding 15 true
The elements in the queue are:
10 11 12 13 14 15 16 17 18 19 20 
Transferring an element
Geeks for Geeks is a computer science portal.
Element transfer is complete

2. Eliminación de elementos

El método remove() proporcionado por LinkedTransferQueue se usa para eliminar un elemento si está presente en esta cola.

Java

// Java Program Demonstrate removing
// elements of LinkedTransferQueue
  
import java.util.concurrent.LinkedTransferQueue;
  
class RemoveElementsExample {
    public static void main(String[] args)
    {
        // Initializing the queue
        LinkedTransferQueue<Integer> queue
            = new LinkedTransferQueue<Integer>();
  
        // Adding elements to this queue
        for (int i = 1; i <= 5; i++)
            queue.add(i);
  
        // Printing the elements of the queue
        System.out.println(
            "The elements in the queue are:");
        for (Integer i : queue)
            System.out.print(i + " ");
  
        // remove() method will remove the specified
        // element from the queue
        queue.remove(1);
        queue.remove(5);
  
        // Printing the elements of the queue
        System.out.println("\nRemaining elements in queue : ");
        for (Integer i : queue)
            System.out.print(i + " ");
    }
}

 

Producción

The elements in the queue are:
1 2 3 4 5 
Remaining elements in queue : 
2 3 4 

3. Iterando

El método iterator () de LinkedTransferQueue se utiliza para devolver un iterador sobre los elementos de esta cola en la secuencia adecuada.

Java

// Java Program Demonstrate iterating
// over LinkedTransferQueue
  
import java.util.Iterator;
import java.util.concurrent.LinkedTransferQueue;
  
class LinkedTransferQueueIteratorExample {
    public static void main(String[] args)
    {
  
        // Initializing the queue
        LinkedTransferQueue<String> queue
            = new LinkedTransferQueue<String>();
  
        // Adding elements to this queue
        queue.add("Gfg");
        queue.add("is");
        queue.add("fun!!");
  
        // Returns an iterator over the elements
        Iterator<String> iterator = queue.iterator();
  
        // Printing the elements of the queue
        while (iterator.hasNext())
            System.out.print(iterator.next() + " ");
    }
}
Producción

Gfg is fun!! 

Métodos de LinkedTransferQueue

MÉTODO

DESCRIPCIÓN

agregar​(E e) Inserta el elemento especificado al final de esta cola.
contiene​(Objeto o) Devuelve verdadero si esta cola contiene el elemento especificado.
drenajeA​(Colección<? super E> c) Elimina todos los elementos disponibles de esta cola y los agrega a la colección dada.
drenajeA​(Colección<? super E> c, int maxElements) Elimina como máximo el número dado de elementos disponibles de esta cola y los agrega a la colección dada.
forEach​(Consumidor<? super E> acción) Realiza la acción dada para cada elemento del iterable hasta que se hayan procesado todos los elementos o la acción genere una excepción.
esta vacio() Devuelve verdadero si esta cola no contiene elementos.
iterador() Devuelve un iterador sobre los elementos de esta cola en la secuencia adecuada.
oferta​(E e) Inserta el elemento especificado al final de esta cola.
oferta​(E e, tiempo de espera largo, unidad TimeUnit) Inserta el elemento especificado al final de esta cola.
poner​(E e) Inserta el elemento especificado al final de esta cola.
capacidad restante() Siempre devuelve Integer.MAX_VALUE porque LinkedTransferQueue no tiene restricciones de capacidad.
eliminar​(Objeto o) Elimina una sola instancia del elemento especificado de esta cola, si está presente.
removeAll​(Colección<?> c) Elimina todos los elementos de esta colección que también están contenidos en la colección especificada (operación opcional).
removeIf​(predicado<? filtro super E>) Elimina todos los elementos de esta colección que satisfacen el predicado dado.
retenerTodo​(Colección<?> c) Retiene solo los elementos de esta colección que están contenidos en la colección especificada (operación opcional).
Talla() Devuelve el número de elementos en esta cola.
divisor() Devuelve un Spliterator sobre los elementos de esta cola.
aArray() Devuelve una array que contiene todos los elementos de esta cola, en la secuencia adecuada.
a la Array​(T[] a) Devuelve una array que contiene todos los elementos de esta cola, en la secuencia adecuada; el tipo de tiempo de ejecución de la array devuelta es el de la array especificada.
transferencia​(E e) Transfiere el elemento a un consumidor, esperando si es necesario hacerlo.
TryTransfer​(E e) Transfiere el elemento a un consumidor en espera inmediatamente, si es posible.
tryTransfer​(E e, tiempo de espera prolongado, unidad TimeUnit) Transfiere el elemento a un consumidor si es posible hacerlo antes de que transcurra el tiempo de espera.

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

MÉTODO

DESCRIPCIÓN

addAll​(Colección<? extiende E> c) Agrega todos los elementos de la colección especificada a esta cola.
clear() Elimina todos los elementos de esta cola.
elemento() Recupera, pero no elimina, el encabezado de esta cola.
retirar() Recupera y elimina el encabezado de esta cola.

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

MÉTODO

DESCRIPCIÓN

contieneTodo​(Colección<?> c) Devuelve verdadero si esta colección contiene todos los elementos de la colección especificada.
Enstringr() Devuelve una representación de string de esta colección.

Métodos declarados en la interfaz java.util.concurrent.BlockingQueue

MÉTODO

DESCRIPCIÓN

sondeo​(tiempo de espera prolongado, unidad TimeUnit) Recupera y elimina el encabezado de esta cola, esperando hasta el tiempo de espera especificado si es necesario para que un elemento esté disponible.
tomar() Recupera y elimina el encabezado de esta cola, esperando si es necesario hasta que un elemento esté disponible.

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

MÉTODO

DESCRIPCIÓN

addAll​(Colección<? extiende E> c) Agrega todos los elementos de la colección especificada a esta colección (operación opcional).
clear() Elimina todos los elementos de esta colección (operación opcional).
contieneTodo​(Colección<?> c) Devuelve verdadero si esta colección contiene todos los elementos de la colección especificada.
es igual a​(Objeto o) Compara el objeto especificado con esta colección para la igualdad.
código hash() Devuelve el valor del código hash para esta colección.
flujoParalelo() Devuelve un Stream posiblemente paralelo con esta colección como fuente.
corriente() Devuelve un Stream secuencial con esta colección como fuente.
toArray​(IntFunction<T[]> generador) Devuelve una array que contiene todos los elementos de esta colección, utilizando la función de generador proporcionada para asignar la array devuelta.

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

MÉTODO

DESCRIPCIÓN

elemento() Recupera, pero no elimina, el encabezado de esta cola.
ojeada() Recupera, pero no elimina, el encabezado de esta cola o devuelve un valor nulo si esta cola está vacía.
encuesta() Recupera y elimina el encabezado de esta cola, o devuelve un valor nulo si esta cola está vacía.
retirar() Recupera y elimina el encabezado de esta cola.

Métodos declarados en la interfaz java.util.concurrent.TransferQueue

MÉTODO

DESCRIPCIÓN

getWaitingConsumerCount() Devuelve una estimación de la cantidad de consumidores que esperan recibir elementos a través de BlockingQueue.take() o timed poll .
tieneConsumidorEsperando() Devuelve verdadero si hay al menos un consumidor esperando recibir un elemento a través de BlockingQueue.take() o timed poll .

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

Publicación traducida automáticamente

Artículo escrito por RishabhPrabhu y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *