Java 中 LinkedTransferQueue tryTransfer() 方法及示例

2025 年 1 月 6 日 | 阅读 6 分钟

在 Java 中，LinkedTransferQueue 是一个并发队列实现，它结合了传统阻塞队列和直接移交队列的特性。它实现了继承自 BlockingQueue 类的 TransferQueue 接口，并通过提供额外的方法扩展了生产者-消费者场景的功能。

LinkedTransferQueue 类中的 tryTransfer() 方法用于在生产者线程中立即将元素传输给正在等待的消费者线程。如果不存在等待的消费者，该方法会直接返回 false 而不将元素入队，因此该方法在需要立即传递元素但没有消费者等待的情况下很有用，生产者可以据此决定如何处理该元素。

方法签名

解释

boolean: 返回一个布尔值，指示传输是否成功（true）或失败（false）。

tryTransfer: 这是方法的名称。

(E e): 它接受一个类型为 E 的参数，E 代表 LinkedTransferQueue 中存储的元素类型。参数 e 是要传输的元素。

E: 它是队列中元素类型的占位符，在实例化 LinkedTransferQueue 时指定。例如，如果您创建一个整数的 LinkedTransferQueue，它将是 LinkedTransferQueue<Integer>。

示例 1：与多个生产者一起使用

在“与多个生产者一起使用”示例中，我们将探讨如何将 LinkedTransferQueue 的 tryTransfer() 方法与多个生产者线程一起使用，这些线程尝试将元素传输给一个消费者。此示例演示了使用 LinkedTransferQueue 在多个生产者和单个消费者之间进行协调。

文件名: 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();
    }
}

输出

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

示例 2：NullPointerException

在此示例中，我们创建一个名为 transferQueue 的新的 LinkedTransferQueue 对象。它用 String 进行参数化，意味着它将存储 String 类型的元素。使用 lambda 表达式创建一个新线程。在线程中，它尝试使用 transferQueue 的 tryTransfer() 方法传输一个 null 元素。如果在传输过程中发生 NullPointerException，则会捕获并打印出来。

文件名: 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);
        }
    }
}

输出

Transferring an element...
java.lang.NullPointerException

示例 3：传输对象

在此示例中，我们演示了如何使用 LinkedTransferQueue 的 tryTransfer() 方法在线程之间传输对象。我们将创建一个简单的生产者-消费者场景，其中一个生产者线程使用 LinkedTransferQueue 将自定义对象传输给一个消费者线程。

文件名: 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();
    }
}

输出

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.

示例 4：处理超时

在此示例中，我们演示了如何使用 LinkedTransferQueue 的 tryTransfer() 方法处理元素传输时的超时情况。在某些情况下，我们可能希望尝试传输，但不想无限期地等待消费者接收元素。我们可以指定一个超时持续时间，如果在该时间内没有可用的消费者，则传输将不会发生。

文件名: 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();
    }
}

输出

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

示例 5：与多个生产者和超时一起使用

在此示例中，我们演示了如何在 LinkedTransferQueue 中将 tryTransfer() 方法与多个生产者和超时一起使用。在某些情况下，我们可能有多个生产者尝试将元素传输给单个消费者，并且我们希望处理在指定超时时间内无法完成传输的情况。

文件名: 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();
    }
}

输出

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.

示例 6：非阻塞传输

在此示例中，我们演示了如何使用 LinkedTransferQueue 的 tryTransfer() 方法在线程之间执行非阻塞元素传输。与 transfer() 方法（该方法会阻塞直到有消费者可用以接收元素）相反，tryTransfer() 会立即返回，指示传输是否成功。

文件名: 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();
    }
}

输出

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

下一个主题Java 中的相等计数子字符串数

Java 中 LinkedTransferQueue tryTransfer() 方法及示例

方法签名

示例 1：与多个生产者一起使用

示例 2：NullPointerException

示例 3：传输对象

示例 4：处理超时

示例 5：与多个生产者和超时一起使用

示例 6：非阻塞传输

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中 LinkedTransferQueue tryTransfer() 方法及示例

方法签名

示例 1：与多个生产者一起使用

示例 2：NullPointerException

示例 3：传输对象

示例 4：处理超时

示例 5：与多个生产者和超时一起使用

示例 6：非阻塞传输

相关帖子

Java 本地化

Java ArrayList 长度

Java 中的哲学家就餐问题及解决方案

What is truncation in Java

Java 中使用多线程进行单词计数

Program to Accept String Starting With Capital Letter in Java

Java 中获取两个日期的总小时数

Java 中返回多个值

Delegation Event Model in Java

Banker's Algorithm Java

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器