LinkedTransferQueue in Java
Last Updated : 20 Feb, 2025
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.
- Most of its methods are non-blocking, offering thread-safe operations without locking.
- It can grow dynamically to accommodate more elements without any predefined limit.
- Optimized for high-throughput and low-latency transfers in multi-threaded environments.
- The transfer() method allows producers to send elements directly to consumers.
Example: This example, demonstrates how to add elements to a LinkedTransferQueue and then retrieve and print them using poll() until the queue is empty.
Java // Java Program to demonstrate the // working of LinkedTransferQueue import java.util.concurrent.*; public class Geeks { public static void main(String[] args) { // Create a LinkedTransferQueue LinkedTransferQueue<String> q = new LinkedTransferQueue<>(); // Add some elements to the queue q.add("1"); q.add("2"); q.add("3"); // Print the elements of the queue System.out.println("LinkedTransferQueue is: "); while (!q.isEmpty()) { System.out.print(q.poll() + " "); } } } OutputLinkedTransferQueue is: 1 2 3
LinkedTransferQueue Hierarchy
Declaration of LinkedTransferQueue
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)
Constructors
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.
Java // Java Program to demonstrates how // to copy elements to another LinkedTransferQueue import java.util.concurrent.LinkedTransferQueue; public class Geeks { public static void main(String[] args) { // Create object of LinkedTransferQueue LinkedTransferQueue<Integer> l = new LinkedTransferQueue<Integer>(); // Add numbers to the LinkedTransferQueue l.add(1); l.add(2); l.add(3); l.add(4); // Print Queue 1 System.out.println("LinkedTransferQueue1: " + l); // Create a new LinkedTransferQueue // with the elements from the first queue LinkedTransferQueue<Integer> l2 = new LinkedTransferQueue<Integer>(l); // Print Queue 2 System.out.println("LinkedTransferQueue2: " + l2); } } OutputLinkedTransferQueue1: [1, 2, 3, 4] LinkedTransferQueue2: [1, 2, 3, 4]
Example 2: This example demonstrates how use various methods of LinkedTransferQueue.
Java // Java Program to demosntrate the // working of add(), poll() and size() method import java.util.concurrent.LinkedTransferQueue; import java.util.*; public class Geeks { public static void main(String[] args) throws InterruptedException { // create object of LinkedTransferQueue LinkedTransferQueue<Integer> l = new LinkedTransferQueue<Integer>(); // Add numbers to end of LinkedTransferQueue // using add() method l.add(10); l.add(20); l.add(30); l.add(40); // prints the Queue System.out.println("LinkedTransferQueue: " + l); // prints the size of Queue after removal // using size() method System.out.println("Size of LinkedTransferQueue: " + l.size()); // removes the front element and prints it // using poll() method System.out.println("First element: " + l.poll()); // prints the Queue System.out.println("Linked Transfer Queue: " + l); System.out.println("Size of LinkedTransferQueue: " + l.size()); } } OutputLinkedTransferQueue: [10, 20, 30, 40] Size of LinkedTransferQueue: 4 First element: 10 Linked Transfer Queue: [20, 30, 40] Size of LinkedTransferQueue: 3
Performing Various Operations on LinkedTransferQueue
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.
Java // Java Program to demonstrate adding // elements to LinkedTransferQueue import java.util.concurrent.*; class Geeks { public static void main(String[] args) { // Initializing the queue LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>(); // Adding elements to this queue for (int i = 10; i <= 14; i++) q.add(i); // Add the element using offer() method System.out.println("adding 15 " + q.offer(15, 5, TimeUnit.SECONDS)); // Adding elements to this queue for (int i = 16; i <= 20; i++) q.put(i); // Printing the elements of the queue System.out.println( "The elements in the queue are:"); for (Integer i : q) 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); } } } Outputadding 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.
Java // Java Program to demonstrate removing // elements of LinkedTransferQueue import java.util.concurrent.LinkedTransferQueue; class Geeks { public static void main(String[] args) { // Initializing the q LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>(); // Adding elements to this q for (int i = 1; i <= 5; i++) q.add(i); // Printing the elements of the q System.out.println( "The elements in the Queue are:"); for (Integer i : q) System.out.print(i + " "); // remove() method will remove the specified // element from the q q.remove(1); q.remove(5); // Printing the elements of the q System.out.println( "\nRemaining elements in Queue are : "); for (Integer i : q) System.out.print(i + " "); } } OutputThe 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.
Java // Java Program to demonstrate iterating // over LinkedTransferQueue import java.util.Iterator; import java.util.concurrent.LinkedTransferQueue; class Geeks { public static void main(String[] args) { // Initializing the queue LinkedTransferQueue<String> q = new LinkedTransferQueue<String>(); // Adding elements to this queue q.add("GeeksForGeeks"); q.add("is"); q.add("fun!!"); // Returns an iterator over the elements Iterator<String> i = q.iterator(); // Printing the elements of the queue while (i.hasNext()) System.out.print(i.next() + " "); } } OutputGeeksForGeeks is fun!!
Methods
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. |
Methods Declared in Class java.util.AbstractQueue
Methods Declared in Class java.util.AbstractCollection
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. |
Methods Declared in Interface java.util.concurrent.BlockingQueue
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. |
Methods Declared in Interface java.util.Collection
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. |
Methods Declared in Interface java.util.Queue
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. |
Methods Declared in Interface java.util.concurrent.TransferQueue