Интерфейс TransferQueue в Java

Опубликовано: 4 Февраля, 2022

Интерфейс TransferQueue является членом Java Collections Framework. Он был представлен в JDK 1.7, принадлежит пакету java.util.concurrent. TransferQueue - это BlockingQueue, в которой отправляющий поток (производитель) может ждать, пока принимающий поток (потребители) получит элементы. TransferQueue используется в приложениях для передачи сообщений. Есть два аспекта, в которых сообщение будет передано из потока-производителя в поток-получатель.

  • put (E e) : этот метод используется, если производитель хочет поставить элементы в очередь, не дожидаясь потребителя. Однако он ждет, пока пространство не станет доступным, если очередь заполнена.
  • transfer (E e) : этот метод обычно используется для передачи элемента потоку, который ожидает его получения, если нет ожидающего потока, он будет ждать, пока поток не перейдет в состояние ожидания, как только появится ожидающий поток элемент будет перенесен в него.

TransferQueue также может быть запрошен с помощью hasWaitingConsumer () , есть ли какие-либо потоки, ожидающие элементов, что является обратной аналогией операции просмотра.

Декларация

 открытый интерфейс TransferQueue <E> расширяет BlockingQueue <E>

Здесь E - это тип элементов, хранящихся в коллекции.

Иерархия TransferQueue

Он расширяет интерфейсы BlockingQueue <E>, Collection <E> , Iterable <E> , Queue <E>.

Example:

Java

// 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);
    }
}
Output
Queue1: [7855642, 35658786, 5278367, 74381793]
Queue2: [7855642, 35658786, 5278367, 74381793]

Реализация классов

TransferQueue имеет один класс реализации - LinkedTransferQueue. LinkedTransferQueue - это неограниченная реализация интерфейса TransferQueue, основанная на связанных узлах. Элементы в LinkedTransferQueue упорядочены в порядке FIFO, причем заголовок указывает на элемент, который находится в очереди дольше всего, а хвост указывает на элемент, который находился в очереди самое короткое время.

Из-за своей асинхронной природы size () просматривает всю коллекцию, поэтому это не операция времени O (1). Это также может дать неточный размер, если эта коллекция будет изменена во время обхода. Не гарантируется, что массовые операции, такие как addAll, removeAll, keepAll, containsAll, equals и toArray, будут выполняться атомарно. Например, итератор, работающий одновременно с операцией addAll, может наблюдать только некоторые из добавленных элементов.

Синтаксис:

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

Основные операции

1. Добавление элементов

The implementation of various methods is provided by LinkedTransferQueue to add or insert elements. They are add(E e), put(E e), offer(E e), transfer(E e). add, put, and offer methods do not care about other threads accessing the queue or not while transfer() waits for one or more recipient threads.

Java

// 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);
        }
    }
}
Output
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. Удаление элементов

The remove() method implementation provided by LinkedTransferQueue is used to remove an element if it is present in this queue.

Java

// 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(" Remaining elements in queue : ");
        for (Integer i : queue)
            System.out.print(i + " ");
    }
}
Output
The elements in the queue are:
1 2 3 4 5 
Remaining elements in queue : 
2 3 4

3. Итерация

The iterator() method implementation provided by LinkedTransferQueue is used to return an iterator over the elements in this queue in the proper sequence.

Java

// 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() + " ");
    }
}
Output
Gfg is fun!! 

Methods of TransferQueue

METHOD

DESCRIPTION

getWaitingConsumerCount()Returns an estimate of the number of consumers waiting to receive elements via BlockingQueue.take() or timed poll.
hasWaitingConsumer()Returns true if there is at least one consumer waiting to receive an element via BlockingQueue.take() or timed poll.
transfer​(E e)Transfers the element to a consumer, waiting if necessary to do so.
tryTransfer​(E e)Transfers the element to a waiting consumer immediately, if possible.
tryTransfer​(E e, long timeout, TimeUnit unit)Transfers the element to a consumer if it is possible to do so before the timeout elapses.

Methods declared in interface java.util.concurrent.BlockingQueue

METHODDESCRIPTION
add​(E e)Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
contains​(Object o)Returns true if this queue contains the specified element.
drainTo​(Collection<? super E> c)Removes all available elements from this queue and adds them to the given collection.
drainTo​(Collection<? super E> c, int maxElements)Removes at most the given number of available elements from this queue and adds them to the given collection.
offer​(E e)Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and false if no space is currently available.
offer​(E e, long timeout, TimeUnit unit)Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available.
poll​(long timeout, TimeUnit unit)Retrieves and removes the head of this queue, waiting up to the specified wait time if necessary for an element to become available.
put​(E e)Inserts the specified element into this queue, waiting if necessary for space to become available.
remainingCapacity()Returns the number of additional elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking, or Integer.MAX_VALUE if there is no intrinsic limit.
remove​(Object o)Removes a single instance of the specified element from this queue, if it is present.
take()Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.

Methods declared in interface java.util.Collection

METHODDESCRIPTION
addAll​(Collection<? extends E> c)Adds all of the elements in the specified collection to this collection (optional operation).
clear()Removes all of the elements from this collection (optional operation).
containsAll​(Collection<?> c)Returns true if this collection contains all of the elements in the specified collection.
equals​(Object o)Compares the specified object with this collection for equality.
hashCode()Returns the hash code value for this collection.
isEmpty()Returns true if this collection contains no elements.
iterator()Returns an iterator over the elements in this collection.
parallelStream()Returns a possibly parallel Stream with this collection as its source.
removeAll​(Collection<?> c)Removes all of this collection’s elements that are also contained in the specified collection (optional operation).
removeIf​(Predicate<? super E> filter)Removes all of the elements of this collection that satisfy the given predicate.
retainAll​(Collection<?> c)Retains only the elements in this collection that are contained in the specified collection (optional operation).
size()Returns the number of elements in this collection.
spliterator()Creates a Spliterator over the elements in this collection.
stream()Returns a sequential Stream with this collection as its source.
toArray()Returns an array containing all of the elements in this collection.
toArray​(IntFunction<T[]> generator)Returns an array containing all of the elements in this collection, using the provided generator function to allocate the returned array.
toArray​(T[] a)Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.

Methods declared in interface java.lang.Iterable

METHODDESCRIPTION
forEach​(Consumer<? super T> action)Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception.

Methods declared in interface java.util.Queue

METHODDESCRIPTION
element()Retrieves, but does not remove, the head of this queue.
peek()Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
poll()Retrieves and removes the head of this queue, or returns null if this queue is empty.
remove()Retrieves and removes the head of this queue.

Ссылка: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TransferQueue.html

Вниманию читателя! Не переставай учиться сейчас. Ознакомьтесь со всеми важными концепциями Java Foundation и коллекций с помощью курса "Основы Java и Java Collections" по доступной для студентов цене и будьте готовы к работе в отрасли. Чтобы завершить подготовку от изучения языка к DS Algo и многому другому, см. Полный курс подготовки к собеседованию .