Interfaz TransferQueue en Java

La interfaz TransferQueue es miembro de Java Collections Framework . Fue introducido en JDK 1.7, pertenece al paquete java.util.concurrent . TransferQueue es una BlockingQueue en la que un subproceso de envío (productor) puede esperar a que el subproceso de recepción (consumidores) reciba elementos. TransferQueue se utiliza en aplicaciones de paso de mensajes. Hay dos aspectos en los que el mensaje se pasará del hilo del productor al hilo del consumidor.

• 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.
• 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.

También se puede consultar una TransferQueue, a través de hasWaitingConsumer() , si hay subprocesos esperando elementos, que es una analogía inversa a una operación de inspección.

Declaración

public interface TransferQueue<E> extends BlockingQueue<E>

Aquí, E es el tipo de elementos almacenados en la colección.

La jerarquía de TransferQueue

Extiende las interfaces BlockingQueue<E> , Collection<E> , Iterable<E> , Queue<E> .

Ejemplo:

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

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

Implementando Clases

TransferQueue tiene una clase de implementación que es LinkedTransferQueue . LinkedTransferQueue es una implementación ilimitada de la interfaz TransferQueue 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.

Sintaxis:

TransferQueue<E> objectName = new LinkedTransferQueue<E>();

Operaciones básicas

1. Agregar elementos

LinkedTransferQueue proporciona la implementación de 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 Program Demonstrate adding
// elements to TransferQueue
  
import java.util.concurrent.*;
  
class AddingElementsExample {
    public static void main(String[] args) throws Exception
    { 
  
        // Initializing the queue
        TransferQueue<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
        TransferQueue<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);
        }
    }
}

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

2. Eliminación de elementos

La implementación del método remove() proporcionada por LinkedTransferQueue se usa para eliminar un elemento si está presente en esta cola.

// Java Program Demonstrate removing
// elements of TransferQueue
  
import java.util.concurrent.*;
  
class RemoveElementsExample {
    public static void main(String[] args)
    {
        // Initializing the queue
        TransferQueue<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 + " ");
    }
}

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

3. Iterando

La implementación del método iterator () proporcionada por LinkedTransferQueue se utiliza para devolver un iterador sobre los elementos de esta cola en la secuencia adecuada.

// Java Program Demonstrate 
// iterating over TransferQueue
  
import java.util.Iterator;
import java.util.concurrent.*;
  
class IteratingExample {
    public static void main(String[] args)
    {
  
        // Initializing the queue
        TransferQueue<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() + " ");
    }
}

Gfg is fun!! 

Métodos de TransferQueue

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

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

Métodos declarados en la interfaz java.lang.Iterable

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/TransferQueue.html