![]() |
VOOZH | about |
In Java, the LinkedTransferQueue is a part of the java.util.concurrent package and implements the TransferQueue. It is specifically designed for handling concurrent data transfers. It is a non-blocking, thread-safe, unbounded queue that supports both producer-consumer and transfer operations, making it suitable for high-performance, multi-threaded applications.
Example: This example, demonstrates how to add elements to a LinkedTransferQueue and then retrieve and print them using poll() until the queue is empty.
LinkedTransferQueue is: 1 2 3
In Java, the declaration of LinkedTransferQueue can be done as:
LinkedTransferQueue<Type> queue = new LinkedTransferQueue<>();
Note: Here, the Type is the type of element the queue will store(e.g String, Integer)
Constructor | Description |
|---|---|
LinkedTransferQueue() | This constructor is used to construct an empty queue. |
LinkedTransferQueue(Collection<E> c) | This constructor is used to construct a queue with the elements of the Collection passed as the parameter. |
Example 1: This example demonstrates how to create a LinkedTransferQueue add elements to it, and then copy the elements to another LinkedTransferQueue.
LinkedTransferQueue1: [1, 2, 3, 4] LinkedTransferQueue2: [1, 2, 3, 4]
Example 2: This example demonstrates how use various methods of LinkedTransferQueue.
LinkedTransferQueue: [10, 20, 30, 40] Size of LinkedTransferQueue: 4 First element: 10 Linked Transfer Queue: [20, 30, 40] Size of LinkedTransferQueue: 3
1. Adding Elements: We can use various like add(), put(), offer() method to insert element in a LinkedTransferQueue without waiting for other thread. The transfer() method waits until another thread is ready to take the element.
Example: This example demonstrates adding, offering, and transferring elements in a LinkedTransferQueue including blocking operations like put() and transfer() across thread.
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. Remove Elements: We can use remove() method to remove an element if it is present in the queue.
Example: This example demonstrates how to remove specific element from the queue using remove() method.
The elements in the Queue are: 1 2 3 4 5 Remaining elements in Queue are : 2 3 4
3. Iterating Elements: We can use the iterator() method of LinkedTransferQueue which return an iterator that allows traversing through the elements of the queue.
Example: This example demonstrates iterating over the elements of a LinkedTransferQueue using an iterator.
GeeksForGeeks is fun!!
Methods | Description |
|---|---|
| add(E e) | Inserts the specified element at the tail of this queue. |
| 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. |
| forEach(Consumer<? super E> action) | Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception. |
| isEmpty() | Returns true if this queue contains no elements. |
| iterator() | Returns an iterator over the elements in this queue in proper sequence. |
| offer(E e) | Inserts the specified element at the tail of this queue. |
| offer(E e, long timeout, TimeUnit unit) | Inserts the specified element at the tail of this queue. |
| put(E e) | Inserts the specified element at the tail of this queue. |
| remainingCapacity() | Always returns Integer.MAX_VALUE because a LinkedTransferQueue is not capacity constrained. |
| remove(Object o) | Removes a single instance of the specified element from this queue, if it is present. |
| 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 queue. |
| spliterator() | Returns a Spliterator over the elements in this queue. |
| toArray() | Returns an array containing all of the elements in this queue, in proper sequence. |
| toArray(T[] a) | Returns an array containing all of the elements in this queue, in proper sequence; the runtime type of the returned array is that of the specified array. |
| 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. |
METHOD | DESCRIPTION |
|---|---|
| addAll(Collection<? extends E> c) | Adds all of the elements in the specified collection to this queue. |
| clear() | Removes all of the elements from this queue. |
| element() | Retrieves, but does not remove, the head of this queue. |
| remove() | Retrieves and removes the head of this queue. |
METHOD | DESCRIPTION |
|---|---|
| containsAll(Collection<?> c) | Returns true if this collection contains all of the elements in the specified collection. |
| toString() | Returns a string representation of this collection. |
METHOD | DESCRIPTION |
|---|---|
| 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. |
| take() | Retrieves and removes the head of this queue, waiting if necessary until an element becomes available. |
METHOD | DESCRIPTION |
|---|---|
| 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. |
| parallelStream() | Returns a possibly parallel Stream with this collection as its source. |
| stream() | Returns a sequential Stream with this collection as its source. |
| 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. |
METHOD | DESCRIPTION |
|---|---|
| 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. |
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. |