LinkedTransferQueue tryTransfer() method in Java with Examples

In Java, LinkedTransferQueue is a concurrent queue implementation which possesses the combination of characteristics from both the traditional blocking queues and the direct handoff queues. It implements the TransferQueue interface that is extending the BlockingQueue class and extends the functionalities of the producer-consumer scenario through the offering of additional methods.

The tryTransfer() method in the LinkedTransferQueue class is used to offer an immediately transfer of elements in the producer thread to the consumer thread that is waiting. If a waiting consumer doesn't exist, the method simply returns false without enqueuing the element and thus this method could be useful in the scenarios where the element has to move through immediately, but when no consumer is waiting, the producer can take a decision of how to handle the element.

Method Signature

Explanation

boolean: It returns a boolean value indicating whether the transfer was successful (true) or not (false).

tryTransfer: It is the name of the method.

(E e): It takes an argument of type E, which represents the type of elements held in the LinkedTransferQueue. The parameter e is the element to be transferred.

E: It is a placeholder for the type of elements in the queue, which is specified when LinkedTransferQueue is instantiated. For example, if you create a LinkedTransferQueue of integers, it would be LinkedTransferQueue<Integer>.

Example 1: Using with Multiple Producers

In the "Using with Multiple Producers" example, we'll explore how to use the tryTransfer() method of LinkedTransferQueue with multiple producer threads trying to transfer elements to a consumer and this example demonstrates coordination between multiple producers and a single consumer using LinkedTransferQueue.

Filename: MultipleProducersExample.java

import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;
public class MultipleProducersExample {
    public static void main(String[] args) {
        TransferQueue<Integer> transferQueue = new LinkedTransferQueue<>();
        // Producer thread 1
        Thread producer1 = new Thread(() -> {
            try {
                System.out.println("Producer 1 is trying to transfer element 1...");
                transferQueue.transfer(1); // Guaranteed transfer
                System.out.println("Producer 1: Transfer successful.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // Producer thread 2
        Thread producer2 = new Thread(() -> {
            try {
                Thread.sleep(1000); // Give time for producer1 to attempt transfer first
                System.out.println("Producer 2 is trying to transfer element 2...");
                transferQueue.transfer(2); // Guaranteed transfer
                System.out.println("Producer 2: Transfer successful.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // Consumer thread
        Thread consumer = new Thread(() -> {
            try {
                Thread.sleep(2000); // Simulate some processing time before consumer starts
                System.out.println("Consumer is trying to take element from queue...");
                Integer element = transferQueue.take();
                System.out.println("Consumer received element: " + element);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        producer1.start();
        producer2.start();
        consumer.start();
    }
}

Output

Producer 1 is trying to transfer element 1...
Producer 2 is trying to transfer element 2...
Consumer is trying to take element from queue...
Producer 1: Transfer successful.
Consumer received element: 1

Example 2: NullPointerException

In this example, we create a new LinkedTransferQueue object named transferQueue. It is parameterized with String, meaning it will hold elements of type String. A new thread is created using a lambda expression. Inside the thread, it attempts to transfer a null element using tryTransfer() method of transferQueue. If a NullPointerException occurs during the transfer, it's caught and printed.

Filename: Example.java

import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;
public class Example {
    public static void main(String args[]) {
        // create a LinkedTransferQueue object
        TransferQueue<String> transferQueue = new LinkedTransferQueue<>();
        new Thread(() -> {
            try {
                System.out.println("Transferring an element...");
                // Calling tryTransfer() method
                // to transfer the null element
                transferQueue.tryTransfer(null);
                System.out.println("Element transfer is complete");
            } catch (NullPointerException e) {
                System.out.println(e);
                System.exit(0);
            }
        }).start();
        try {
            System.out.println("Received element: " + transferQueue.take());
            // Here the thread is waiting
            // to receive an element.
        } catch (InterruptedException e) {
            System.out.println(e);
            System.exit(0);
        }
    }
}

Output

Transferring an element...
java.lang.NullPointerException

Example 3: Transferring Objects

In this example, we demonstrate how to transfer objects between threads using the tryTransfer() method of LinkedTransferQueue. We'll create a simple producer-consumer scenario where a producer thread transfers a custom object to a consumer thread using a LinkedTransferQueue.

Filename: Example1.java

import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;
public class Example1 {
    static class Data {
        private final String name;
        Data(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "Data{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    public static void main(String[] args) {
        TransferQueue<Data> transferQueue = new LinkedTransferQueue<>();
        // Producer thread
        Thread producer = new Thread(() -> {
            System.out.println("Producer is trying to transfer data...");
            Data data = new Data("Example");
            try {
                transferQueue.transfer(data); // Guaranteed transfer
                System.out.println("Data " + data + " transferred successfully.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // Consumer thread
        Thread consumer = new Thread(() -> {
            try {
                Thread.sleep(2000); // Simulate some processing time before consumer starts
                System.out.println("Consumer is trying to take data from queue...");
                Data data = transferQueue.take();
                System.out.println("Consumer received data: " + data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        producer.start();
        consumer.start();
    }
}

Output

Producer is trying to transfer data...
Consumer is trying to take data from queue...
Consumer received data: Data{name='Example'}
Data Data{name='Example'} transferred successfully.

Example 4: Handling Timeout

In this example, we demonstrate how to handle timeout scenarios when transferring elements using the tryTransfer() method of LinkedTransferQueue. In some cases, we may want to attempt a transfer but not wait indefinitely for a consumer to receive the element. We can specify a timeout duration, and if no consumer is available within that time, the transfer will not occur.

Filename: HandlingTimeoutExample.java

import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;
import java.util.concurrent.TimeUnit;
public class HandlingTimeoutExample {
    public static void main(String[] args) {
        // Create a LinkedTransferQueue
        TransferQueue<Integer> transferQueue = new LinkedTransferQueue<>();
        // Producer thread
        Thread producer = new Thread(() -> {
            try {
                // Attempt to transfer element 42 with a timeout of 1 second
                System.out.println("Producer is trying to transfer element 42...");
                boolean transferred = transferQueue.tryTransfer(42, 1, TimeUnit.SECONDS);
                // Check if the transfer was successful
                if (transferred) {
                    System.out.println("Element 42 transferred successfully.");
                } else {
                    System.out.println("Timeout occurred, element 42 not transferred.");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // Start the producer thread
        producer.start();
    }
}

Output

Producer is trying to transfer element 42...
Timeout occurred, element 42 not transferred.

Example 5: Using with Multiple Producers and a Timeout

In this example, we demonstrate how to use tryTransfer() method with multiple producers and a timeout in a LinkedTransferQueue. In some scenarios, we may have multiple producers trying to transfer elements to a single consumer, and we want to handle situations where a transfer cannot be completed within a specified timeout duration.

Filename: MultipleProducersWithTimeoutExample.java

import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;
import java.util.concurrent.TimeUnit;
public class MultipleProducersWithTimeoutExample {
    public static void main(String[] args) {
        // Create a LinkedTransferQueue
        TransferQueue<Integer> transferQueue = new LinkedTransferQueue<>();
        // Producer thread 1
        Thread producer1 = new Thread(() -> {
            try {
                // Attempt to transfer element 1 with a timeout of 2 seconds
                System.out.println("Producer 1 is trying to transfer element 1...");
                boolean transferred = transferQueue.tryTransfer(1, 2, TimeUnit.SECONDS);
                // Check if the transfer was successful
                if (transferred) {
                    System.out.println("Producer 1: Element 1 transferred successfully.");
                } else {
                    System.out.println("Producer 1: Timeout occurred, element 1 not transferred.");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // Producer thread 2
        Thread producer2 = new Thread(() -> {
            try {
                // Wait for 1 second before attempting to transfer element 2
                Thread.sleep(1000);
                // Attempt to transfer element 2 with a timeout of 1 second
                System.out.println("Producer 2 is trying to transfer element 2...");
                boolean transferred = transferQueue.tryTransfer(2, 1, TimeUnit.SECONDS);
                // Check if the transfer was successful
                if (transferred) {
                    System.out.println("Producer 2: Element 2 transferred successfully.");
                } else {
                    System.out.println("Producer 2: Timeout occurred, element 2 not transferred.");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // Start the producer threads
        producer1.start();
        producer2.start();
    }
}

Output

Producer 1 is trying to transfer element 1...
Producer 2 is trying to transfer element 2...
Producer 1: Timeout occurred, element 1 not transferred.
Producer 2: Timeout occurred, element 2 not transferred.

Example 6: Non-Blocking Transfer

In this example, we demonstrate the use of the tryTransfer() method with a LinkedTransferQueue to perform a non-blocking transfer of elements between threads. In contrast to the transfer() method, which blocks until a consumer is available to receive the element, tryTransfer() returns immediately, indicating whether the transfer was successful or not.

Filename: NonBlockingTransferExample.java

import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;
public class NonBlockingTransferExample {
    public static void main(String[] args) {
        // Create a LinkedTransferQueue
        TransferQueue<Integer> transferQueue = new LinkedTransferQueue<>();
        // Producer thread
        Thread producer = new Thread(() -> {
            // Attempt to transfer element 42
            System.out.println("Producer is trying to transfer element 42...");
            boolean transferred = transferQueue.tryTransfer(42);
            // Check if the transfer was successful
            if (transferred) {
                System.out.println("Element 42 transferred successfully.");
            } else {
                System.out.println("Element 42 not transferred.");
            }
        });
        // Start the producer thread
        producer.start();
    }
}

Output

Producer is trying to transfer element 42...
Element 42 not transferred.

Next TopicNumber-of-equal-count-substrings-in-java

← prev next →

We provides tutorials and interview questions of all technology like java tutorial, android, java frameworks

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

[email protected].

LinkedTransferQueue tryTransfer() method in Java with Examples

Method Signature

Example 1: Using with Multiple Producers

Example 2: NullPointerException

Example 3: Transferring Objects

Example 4: Handling Timeout

Example 5: Using with Multiple Producers and a Timeout

Example 6: Non-Blocking Transfer

Learn Important Tutorial

B.Tech / MCA

Preparation

Contact info

Follow us

Tutorials

Interview Questions

Online Compiler

Python

AI, ML and Data Science

Java

B.Tech and MCA

Web Technology

Software Testing

Technical Interview

Java Interview

Web Interview

Database Interview

Company Interviews

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java String

Java String Methods

Java Regex

Exception Handling

Java Inner Class

Java Multithreading

Java Synchronization

Java Networking

Java Applet

Java Reflection

Java Conversion

Java JDBC

RMI

Internationalization

Java Array Class

Java AtomicInteger Class

Java AtomicLong Methods

Java Authenticator

Java BigDecimal class

Big Integer Class

Java Boolean class

Java Byte Class

Java Class

Java Collections class

Java Compiler Class

CopyOnWriteArrayList

Java Math Methods

LinkedBlockingDeque

Java Long class

LinkedTransferQueue

Java List

Java MulticastSocket

Java Number Class

Java Phaser Class

ArrayList Methods

Java Thread Methods

Java Projects

Java Programs

Java Misc

Java Date Class

Java ListIterator Class

Java NIO Tutorial

HttpURLConnection

Java Deque

Java HttpCookie Class

Java URL class

Java List Methods

Java Vector class

Java Collection Methods

Java Socket Class

Java Executors

Java Integer Class

Java IdentityHashMap

Java ArrayBlockingQueue

Java Timestamp

Java Spliterator

Java Bitset

Java Instant

LinkedTransferQueue tryTransfer() method in Java with Examples

Method Signature