當前位置: 首頁>>編程示例 >>用法及示例精選 >>正文


Java LinkedTransferQueue用法及代碼示例

LinkedTransferQueueJava 中的類是Java集合框架。它是在JDK 1.7中引入的,它屬於java.util.concurrent包。它實現了TransferQueue並提供基於鏈接節點的無限函數。 LinkedTransferQueue中的元素按照先進先出的順序排列,頭部指向在隊列中停留時間最長的元素,尾部指向在隊列中停留時間最短的元素。由於其異步特性,size() 會遍曆整個集合,因此它不是 O(1) 時間操作。如果在遍曆期間修改此集合,它也可能給出不準確的大小。不保證像 addAll、removeAll、retainAll、containsAll、equals 和 toArray 這樣的批量操作以原子方式執行。例如,與 addAll 操作同時操作的迭代器可能僅觀察到某些添加的元素。

LinkedTransferQueue已使用message-passing應用程序。消息從Producer線程傳遞到Consumer線程有兩個方麵。

  1. put(E e):如果生產者想要將元素入隊而不等待消費者,則使用此方法。但是,如果隊列已滿,它將等待直到空間可用。
  2. transfer(E e) :此方法一般用於將元素傳輸到正在等待接收它的線程,如果沒有線程等待,則一旦等待線程到達元素就會等待,直到有線程進入等待狀態被轉移到其中。

LinkedTransferQueue的層次結構

Hierarchy of LinkedTransferQueue in Java

它實現了可串行化,可迭代<E>,集合<E>,BlockingQueue,傳輸隊列<E>,Queue接口和擴展AbstractQueueAbstractCollection類。

聲明:

public class LinkedTransferQueue<E> extends AbstractQueue<E> implements TransferQueue<E>, Serializable

這裏,E是該集合維護的元素的類型。

LinkedTransferQueue 的構造函數

為了創建 LinkedTransferQueue 的實例,我們需要從java.util.concurrent包。

1.LinkedTransferQueue():該構造函數用於構造一個空隊列。

LinkedTransferQueue<E> ltq = new LinkedTransferQueue<E>();

2. LinkedTransferQueue(Collection<E> c):該構造函數用於構造一個隊列,並將 Collection 的元素作為參數傳遞。

LinkedTransferQueue<E> ltq = new LinkedTransferQueue<E>(Collection<E> c);

示例 1:用 Java 說明 LinkedTransferQueue 的示例程序

Java


// Java Program Demonstrate LinkedTransferQueue 
  
import java.util.concurrent.LinkedTransferQueue; 
import java.util.*; 
  
public class LinkedTransferQueueDemo { 
    public static void main(String[] args) 
        throws InterruptedException 
    { 
        // create object of LinkedTransferQueue 
        // using LinkedTransferQueue() constructor 
        LinkedTransferQueue<Integer> LTQ 
            = new LinkedTransferQueue<Integer>(); 
  
        // Add numbers to end of LinkedTransferQueue 
        LTQ.add(7855642); 
        LTQ.add(35658786); 
        LTQ.add(5278367); 
        LTQ.add(74381793); 
  
        // print Queue 
        System.out.println("Linked Transfer Queue1: " + LTQ); 
  
        // create object of LinkedTransferQueue 
        // using LinkedTransferQueue(Collection c) 
        // constructor 
        LinkedTransferQueue<Integer> LTQ2 
            = new LinkedTransferQueue<Integer>(LTQ); 
  
        // print Queue 
        System.out.println("Linked Transfer Queue2: " + LTQ2); 
    } 
}
輸出
Linked Transfer Queue1: [7855642, 35658786, 5278367, 74381793]
Linked Transfer Queue2: [7855642, 35658786, 5278367, 74381793]

示例 2:

Java


// Java code to illustrate 
// methods of LinkedTransferQueue 
  
import java.util.concurrent.LinkedTransferQueue; 
import java.util.*; 
  
public class LinkedTransferQueueDemo { 
    public static void main(String[] args) 
        throws InterruptedException 
    { 
  
        // create object of LinkedTransferQueue 
        LinkedTransferQueue<Integer> LTQ 
            = new LinkedTransferQueue<Integer>(); 
  
        // Add numbers to end of LinkedTransferQueue 
        // using add() method 
        LTQ.add(7855642); 
        LTQ.add(35658786); 
        LTQ.add(5278367); 
        LTQ.add(74381793); 
  
        // prints the Queue 
        System.out.println("Linked Transfer Queue: " + LTQ); 
  
        // prints the size of Queue after removal 
        // using size() method 
        System.out.println("Size of Linked Transfer Queue: "
                           + LTQ.size()); 
  
        // removes the front element and prints it 
        // using poll() method 
        System.out.println("First element: " + LTQ.poll()); 
  
        // prints the Queue 
        System.out.println("Linked Transfer Queue: " + LTQ); 
  
        // prints the size of Queue after removal 
        // using size() method 
        System.out.println("Size of Linked Transfer Queue: "
                           + LTQ.size()); 
  
        // Add numbers to end of LinkedTransferQueue 
        // using offer() method 
        LTQ.offer(20); 
  
        // prints the Queue 
        System.out.println("Linked Transfer Queue: " + LTQ); 
  
        // prints the size of Queue after removal 
        // using size() method 
        System.out.println("Size of Linked Transfer Queue: "
                           + LTQ.size()); 
    } 
}
輸出
Linked Transfer Queue: [7855642, 35658786, 5278367, 74381793]
Size of Linked Transfer Queue: 4
First element: 7855642
Linked Transfer Queue: [35658786, 5278367, 74381793]
Size of Linked Transfer Queue: 3
Linked Transfer Queue: [35658786, 5278367, 74381793, 20]
Size of Linked Transfer Queue: 4

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 LinkedTransferQueue 
  
import java.util.concurrent.*; 
  
class AddingElementsExample { 
    public static void main(String[] args) 
    { 
  
        // Initializing the queue 
        LinkedTransferQueue<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 
        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); 
        } 
    } 
}
輸出
adding 15 true
The elements in the queue are:
10 11 12 13 14 15 16 17 18 19 20 
Transferring an element
Geeks for Geeks is a computer science portal.
Element transfer is complete

2. 刪除元素

LinkedTransferQueue 提供的 remove() 方法用於刪除此隊列中存在的元素。

Java


// Java Program Demonstrate removing 
// elements of LinkedTransferQueue 
  
import java.util.concurrent.LinkedTransferQueue; 
  
class RemoveElementsExample { 
    public static void main(String[] args) 
    { 
        // Initializing the queue 
        LinkedTransferQueue<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 LinkedTransferQueue 
  
import java.util.Iterator; 
import java.util.concurrent.LinkedTransferQueue; 
  
class LinkedTransferQueueIteratorExample { 
    public static void main(String[] args) 
    { 
  
        // Initializing the queue 
        LinkedTransferQueue<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!! 

LinkedTransferQueue的方法

METHOD

DESCRIPTION

LinkedTransferQueue add() 將指定元素插入此隊列的尾部。
contains(Object o) 如果此隊列包含指定元素,則返回 true。
dropTo(Collection<? super E> c) 從此隊列中刪除所有可用元素並將它們添加到給定集合中。
dropTo(Collection<? super E> c, int maxElements) 從此隊列中刪除最多給定數量的可用元素並將它們添加到給定的集合中。
forEach(消費者<? super E> 操作) 對 Iterable 的每個元素執行給定的操作,直到處理完所有元素或該操作引發異常。
isEmpty() 如果此隊列不包含元素,則返回 true。
iterator() 按正確順序返回此隊列中元素的迭代器。
offer(E e) 將指定元素插入此隊列的尾部。
offer(E e, long timeout, TimeUnit unit) 將指定元素插入此隊列的尾部。
put(E e) 將指定元素插入此隊列的尾部。
remainingCapacity() 始終返回 Integer.MAX_VALUE,因為 LinkedTransferQueue 不受容量限製。
remove(Object o) 從此隊列中刪除指定元素的單個實例(如果存在)。
移除全部(集合<?> c) 刪除指定集合中也包含的所有該集合的元素(可選操作)。
removeIf(Predicate<? super E> 過濾器) 刪除此集合中滿足給定謂詞的所有元素。
keepAll(集合<?> c) 僅保留此集合中包含在指定集合中的元素(可選操作)。
size() 返回此隊列中的元素數量。
spliterator() 返回此隊列中元素的Spliterator
toArray() 返回一個數組,其中按正確的順序包含此隊列中的所有元素。
toArray(T[] a) 返回一個數組,其中包含此隊列中的所有元素(按正確的順序);返回數組的運行時類型是指定數組的運行時類型。
transfer(E e) 將元素傳輸給使用者,並在必要時等待。
tryTransfer(E e) 如果可能,立即將元素傳輸給等待的消費者。
tryTransfer(E e, long timeout, TimeUnit unit) 如果可以在超時之前將元素傳輸給使用者,則將其傳輸給使用者。

類 java.util.AbstractQueue 中聲明的方法

METHOD

DESCRIPTION

AbstractQueue addAll() 將指定集合中的所有元素添加到此隊列。
AbstractQueue clear() 從此隊列中刪除所有元素。
AbstractQueue element() 檢索但不刪除此隊列的頭部。
AbstractQueue remove() 檢索並刪除此隊列的頭部。

類 java.util.AbstractCollection 中聲明的方法

METHOD

DESCRIPTION

AbstractCollection containsAll() 如果此集合包含指定集合中的所有元素,則返回 true。
AbstractCollection toString() 返回此集合的字符串表示形式。

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

METHOD

DESCRIPTION

BlockingQueue poll() 檢索並刪除此隊列的頭部,如果需要元素變得可用,則等待指定的等待時間。
BlockingQueue take() 檢索並刪除此隊列的頭部,如有必要,則等待直到有元素可用。

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

METHOD

DESCRIPTION

Collection addAll() 將指定集合中的所有元素添加到此集合中(可選操作)。
clear() 從此集合中刪除所有元素(可選操作)。
containsAll(集合<?> c) 如果此集合包含指定集合中的所有元素,則返回 true。
equals(Object o) 比較指定對象與此集合是否相等。
hashCode() 返回此集合的哈希碼值。
parallelStream() 返回一個可能並行的 Stream 並以此集合作為其源。
stream() 返回以此集合作為源的順序 Stream。
toArray(IntFunction<T[]> 生成器) 返回一個包含此集合中所有元素的數組,使用提供的生成器函數分配返回的數組。

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

METHOD

DESCRIPTION

Queue element() 檢索但不刪除此隊列的頭部。
Queue peek() 檢索但不刪除此隊列的頭部,如果此隊列為空,則返回 null。
Queue poll() 檢索並刪除此隊列的頭部,如果此隊列為空,則返回 null。
Queue remove() 檢索並刪除此隊列的頭部。

接口 java.util.concurrent.TransferQueue 中聲明的方法

METHOD

DESCRIPTION

LinkedTransferQueue getWaitingConsumerCount() 返回通過 BlockingQueue.take() 或定時 poll 等待接收元素的消費者數量的估計值。
LinkedTransferQueue hasWaitingConsumer() 如果至少有一個消費者正在等待通過 BlockingQueue.take() 或定時 poll 接收元素,則返回 true。

參考:https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/LinkedTransferQueue.html



相關用法


注:本文由純淨天空篩選整理自RishabhPrabhu大神的英文原創作品 LinkedTransferQueue in Java with Examples。非經特殊聲明,原始代碼版權歸原作者所有,本譯文未經允許或授權,請勿轉載或複製。