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。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。