Java TransferQueue用法及代码示例

TransferQueue接口是一个成员Java集合框架。它是在JDK 1.7中引入的，它属于java.util.concurrent包。 TransferQueue 是 BlockingQueue，其中发送线程(生产者)可以等待接收线程(消费者)接收元素。 TransferQueue 用于message-passing 应用程序。消息从Producer线程传递到Consumer线程有两个方面。

把(E e)：如果生产者想要将元素入队而不等待消费者，则使用此方法。但是，如果队列已满，它将等待直到空间可用。
转移(E e)：该方法一般用于将元素传送到正在等待接收的线程，如果没有线程等待则等待，直到有线程进入等待状态，一旦等待线程到达，元素就会被传送到它。

还可以通过hasWaitingConsumer()查询TransferQueue是否有任何线程在等待项目，这与查看操作相反。

声明

public interface TransferQueue<E> extends BlockingQueue<E>

这里，E是集合中存储的元素的类型。

TransferQueue的层次结构

Hierarchy-of-TransferQueue-in-Java

它延伸BlockingQueue,集合<E>,可迭代<E>,Queue接口。

例子：

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); 
    } 
}

输出

Queue1: [7855642, 35658786, 5278367, 74381793]
Queue2: [7855642, 35658786, 5278367, 74381793]

实现类

TransferQueue 有一个实现类，它是LinkedTransferQueue.这LinkedTransferQueue是基于链接节点的TransferQueue接口的无限制实现。 LinkedTransferQueue中的元素按照先进先出的顺序排列，头部指向在队列中停留时间最长的元素，尾部指向在队列中停留时间最短的元素。

由于其异步特性，size() 会遍历整个集合，因此它不是 O(1) 时间操作。如果在遍历期间修改此集合，它也可能给出不准确的大小。不保证像 addAll、removeAll、retainAll、containsAll、equals 和 toArray 这样的批量操作以原子方式执行。例如，与 addAll 操作同时操作的迭代器可能仅观察到某些添加的元素。

用法:

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

Basic Operations

1. 添加元素

LinkedTransferQueue提供了各种方法的实现来添加或插入元素。它们是add(E e)、put(E e)、offer(E e)、transfer(E e)。当 transfer() 等待一个或多个接收线程时，add、put 和 Offer 方法不关心其他线程是否访问队列。

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); 
        } 
    } 
}

输出

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. 删除元素

LinkedTransferQueue 提供的 remove() 方法实现用于删除此队列中存在的元素。

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("\nRemaining elements in queue : "); 
        for (Integer i : queue) 
            System.out.print(i + " "); 
    } 
}

输出

The elements in the queue are:
1 2 3 4 5 
Remaining elements in queue : 
2 3 4

3. 迭代

LinkedTransferQueue 提供的 iterator() 方法实现用于按正确的顺序返回对此队列中元素的迭代器。

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() + " "); 
    } 
}

输出

Gfg is fun!!

TransferQueue的方法

METHOD	DESCRIPTION
getWaitingConsumerCount()	返回通过 BlockingQueue.take() 或定时轮询等待接收元素的消费者数量的估计值。
hasWaitingConsumer()	如果至少有一个消费者正在等待通过 BlockingQueue.take() 或定时轮询接收元素，则返回 true。
transfer(E e)	将元素传输给使用者，并在必要时等待。
tryTransfer(E e)	如果可能，立即将元素传输给等待的消费者。
tryTransfer(E e, long timeout, TimeUnit unit)	如果可以在超时之前将元素传输给使用者，则将其传输给使用者。

接口 java.util.concurrent.BlockingQueue 中声明的方法

METHOD	DESCRIPTION
BlockingQueue add()	如果可以立即插入指定元素而不违反容量限制，则将指定元素插入此队列，成功时返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
BlockingQueue contains()	如果此队列包含指定元素，则返回 true。
dropTo(Collection<? super E> c)	从此队列中删除所有可用元素并将它们添加到给定集合中。
dropTo(Collection<? super E> c, int maxElements)	从此队列中删除最多给定数量的可用元素并将它们添加到给定的集合中。
offer(E e)	如果可以在不违反容量限制的情况下立即执行此操作，则将指定元素插入此队列，成功时返回 true，如果当前没有可用空间则返回 false。
offer(E e, long timeout, TimeUnit unit)	将指定的元素插入此队列中，如果需要空间可用，则等待指定的等待时间。
poll(long timeout, TimeUnit unit)	检索并删除此队列的头部，如果需要元素变得可用，则等待指定的等待时间。
put(E e)	将指定的元素插入此队列，必要时等待空间可用。
remainingCapacity()	返回此队列理想情况下(在没有内存或资源限制的情况下)可以无阻塞地接受的附加元素的数量，如果没有内在限制，则返回 Integer.MAX_VALUE。
BlockingQueue remove()	从此队列中删除指定元素的单个实例(如果存在)。
take()	检索并删除此队列的头部，如有必要，则等待直到有元素可用。

接口 java.util.Collection 中声明的方法

METHOD	DESCRIPTION
addAll(集合 <? 扩展 E> c)	将指定集合中的所有元素添加到此集合中(可选操作)。
Collection clear()	从此集合中删除所有元素(可选操作)。
containsAll(集合<?> c)	如果此集合包含指定集合中的所有元素，则返回 true。
equals(Object o)	比较指定对象与此集合是否相等。
hashCode()	返回此集合的哈希码值。
isEmpty()	如果此集合不包含任何元素，则返回 true。
iterator()	返回此集合中元素的迭代器。
parallelStream()	返回一个可能并行的 Stream 并以此集合作为其源。
移除全部(集合<?> c)	删除指定集合中也包含的所有该集合的元素(可选操作)。
removeIf(Predicate<? super E> 过滤器)	删除此集合中满足给定谓词的所有元素。
keepAll(集合<?> c)	仅保留此集合中包含在指定集合中的元素(可选操作)。
size()	返回此集合中的元素数量。
spliterator()	在此集合中的元素上创建Spliterator。
stream()	返回以此集合作为源的顺序 Stream。
toArray()	返回一个包含此集合中所有元素的数组。
toArray(IntFunction<T[]> 生成器)	返回一个包含此集合中所有元素的数组，使用提供的生成器函数分配返回的数组。
toArray(T[] a)	返回一个包含该集合中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

接口 java.lang.Iterable 中声明的方法

METHOD	DESCRIPTION
Iterable forEach()	对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常。

接口 java.util.Queue 中声明的方法

METHOD	DESCRIPTION
Queue element()	检索但不删除此队列的头部。
Queue peek()	检索但不删除此队列的头部，如果此队列为空，则返回 null。
Queue poll()	检索并删除此队列的头部，如果此队列为空，则返回 null。
Queue remove()	检索并删除此队列的头部。

参考：https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TransferQueue.html

相关用法

注：本文由纯净天空筛选整理自佚名大神的英文原创作品 TransferQueue Interface in Java。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。