# Java `PriorityBlockingQueue`類 > 原文： [https://howtodoinjava.com/java/collections/java-priorityblockingqueue/](https://howtodoinjava.com/java/collections/java-priorityblockingqueue/) Java `PriorityBlockingQueue`類是**并發**阻塞隊列數據結構實現，其中根據對象的**優先級**處理對象。 添加名稱的“阻塞”部分意味著**線程將阻塞等待**，直到隊列上有可用的項目為止。 在`PriorityBlockingQueue`中，添加的對象根據其優先級進行排序。 默認情況下，優先級由對象的自然順序決定。 隊列構建時提供的[比較器](https://howtodoinjava.com/java/collections/java-comparator/)可以覆蓋默認優先級。  優先阻塞隊列 ## 1\. `PriorityBlockingQueue`特性 讓我們記下`PriorityBlockingQueue`上的幾個要點。 * `PriorityBlockingQueue`是一個無界隊列，并且會動態增長。 默認初始容量為`'11'`，可以在適當的構造器中使用`initialCapacity`參數來覆蓋。 * 它提供了阻塞檢索操作。 * 它不允許使用`NULL`對象。 * 添加到`PriorityBlockingQueue`的對象必須具有可比性，否則會拋出`ClassCastException`。 * 默認情況下，優先級隊列的對象以自然順序排序。 * 比較器可用于隊列中對象的自定義排序。 * 優先級隊列的**頭**是基于自然排序或基于比較器排序的**最小**元素。 當我們輪詢隊列時，它從隊列中返回頭對象。 * 如果存在多個具有相同優先級的對象，則它可以隨機輪詢其中的任何一個。 * `PriorityBlockingQueue`是**線程安全的**。 * 方法`iterator()`中提供的`Iterator`不能保證以任何特定順序遍歷`PriorityBlockingQueue`的元素。 如果需要有序遍歷，請考慮使用`Arrays.sort(pbq.toArray())`。 * `rainToTo()`可用于按優先級順序刪除部分或全部元素，并將它們放置在另一個集合中。 ## 2\. Java `PriorityBlockingQueue`示例 讓我們看看對象的排序如何影響`PriorityBlockingQueue`中的添加和刪除操作。 在給定的示例中，對象的類型為`Employee`。 `Employee`類實現[`Comparable`](https://howtodoinjava.com/java/collections/java-comparable-interface/)接口，默認情況下，該接口使對象可與員工`'id'`字段進行比較。 ```java public class Employee implements Comparable<Employee> { private Long id; private String name; private LocalDate dob; public Employee(Long id, String name, LocalDate dob) { super(); this.id = id; this.name = name; this.dob = dob; } @Override public int compareTo(Employee emp) { return this.getId().compareTo(emp.getId()); } //Getters and setters @Override public String toString() { return "Employee [id=" + id + ", name=" + name + ", dob=" + dob + "]"; } } ``` #### 2.1 自然排序 Java `PriorityBlockingQueue`示例，用于添加和輪詢根據自然順序進行比較的元素。 ```java PriorityBlockingQueue<Employee> PriorityBlockingQueue = new PriorityBlockingQueue<>(); PriorityBlockingQueue.add(new Employee(1l, "AAA", LocalDate.now())); PriorityBlockingQueue.add(new Employee(4l, "CCC", LocalDate.now())); PriorityBlockingQueue.add(new Employee(5l, "BBB", LocalDate.now())); PriorityBlockingQueue.add(new Employee(2l, "FFF", LocalDate.now())); PriorityBlockingQueue.add(new Employee(3l, "DDD", LocalDate.now())); PriorityBlockingQueue.add(new Employee(6l, "EEE", LocalDate.now())); while(true) { Employee e = PriorityBlockingQueue.poll(); System.out.println(e); if(e == null) break; } ``` 程序輸出。 ```java Employee [id=1, name=AAA, dob=2018-10-31] Employee [id=2, name=FFF, dob=2018-10-31] Employee [id=5, name=BBB, dob=2018-10-31] Employee [id=4, name=CCC, dob=2018-10-31] Employee [id=3, name=DDD, dob=2018-10-31] Employee [id=6, name=EEE, dob=2018-10-31] ``` #### 2.2 `PriorityBlockingQueue`比較器示例 讓我們使用[**基于 Java 8 lambda 的比較器**](https://howtodoinjava.com/java8/using-comparator-becomes-easier-with-lambda-expressions-java-8/)語法重新定義自定義順序，并驗證結果。 我們正在使用構造器`PriorityBlockingQueue(int initialCapacity, Comparator comparator）`。 ```java //Comparator for name field Comparator<Employee> nameSorter = Comparator.comparing(Employee::getName); PriorityBlockingQueue<Employee> PriorityBlockingQueue = new PriorityBlockingQueue<>( 11, nameSorter ); PriorityBlockingQueue.add(new Employee(1l, "AAA", LocalDate.now())); PriorityBlockingQueue.add(new Employee(4l, "CCC", LocalDate.now())); PriorityBlockingQueue.add(new Employee(5l, "BBB", LocalDate.now())); PriorityBlockingQueue.add(new Employee(2l, "FFF", LocalDate.now())); PriorityBlockingQueue.add(new Employee(3l, "DDD", LocalDate.now())); PriorityBlockingQueue.add(new Employee(6l, "EEE", LocalDate.now())); while(true) { Employee e = PriorityBlockingQueue.poll(); System.out.println(e); if(e == null) break; } ``` 程序輸出： ```java Employee [id=1, name=AAA, dob=2018-10-31] Employee [id=5, name=BBB, dob=2018-10-31] Employee [id=4, name=CCC, dob=2018-10-31] Employee [id=3, name=DDD, dob=2018-10-31] Employee [id=6, name=EEE, dob=2018-10-31] Employee [id=2, name=FFF, dob=2018-10-31] ``` #### 2.3 `PriorityBlockingQueuerainTo()`示例 Java 示例，使用`drianTo()`方法在一條語句中從隊列中獲取多個元素。 ```java PriorityBlockingQueue<Integer> priorityBlockingQueue = new PriorityBlockingQueue<>(); priorityBlockingQueue.add(1); priorityBlockingQueue.add(3); priorityBlockingQueue.add(2); priorityBlockingQueue.add(6); priorityBlockingQueue.add(4); priorityBlockingQueue.add(5); ArrayList<Integer> list = new ArrayList<>(); //Drain first 3 elements priorityBlockingQueue.drainTo(list, 3); System.out.println(list); //Drain all elements priorityBlockingQueue.drainTo(list); System.out.println(list); ``` 程序輸出： ```java [1, 2, 3] [1, 2, 3, 4, 5, 6] ``` #### 2.4 `PriorityBlockingQueue`阻塞檢索示例 Java 示例，它使用阻塞檢索從`PriorityBlockingQueue`中獲取元素。 線程將等待，直到隊列中存在某個元素。 在給定的示例中，線程正在使用`take()`方法以無限循環在隊列中等待。 等待 1 秒鐘，然后再次檢查。 一旦我們將元素添加到隊列中，它就會輪詢該項目并打印到控制臺。 ```java import java.util.concurrent.PriorityBlockingQueue; import java.util.concurrent.TimeUnit; public class PriorityQueueExample { public static void main(String[] args) throws InterruptedException { PriorityBlockingQueue<Integer> priorityBlockingQueue = new PriorityBlockingQueue<>(); new Thread(() -> { System.out.println("Waiting to poll ..."); try { while(true) { Integer poll = priorityBlockingQueue.take(); System.out.println("Polled : " + poll); Thread.sleep(TimeUnit.SECONDS.toMillis(1)); } } catch (InterruptedException e) { e.printStackTrace(); } }).start(); Thread.sleep(TimeUnit.SECONDS.toMillis(2)); priorityBlockingQueue.add(1); Thread.sleep(TimeUnit.SECONDS.toMillis(2)); priorityBlockingQueue.add(2); Thread.sleep(TimeUnit.SECONDS.toMillis(2)); priorityBlockingQueue.add(3); } } ``` 程序輸出： ```java Waiting to poll ... Polled : 1 Polled : 2 Polled : 3 ``` ## 3\. Java `PriorityBlockingQueue`構造器 `PriorityBlockingQueue`類提供了 4 種不同的方法來用 Java 構造優先級隊列。 * **`PriorityBlockingQueue()`**：構造一個空隊列，其默認初始容量為（11），該初始容量根據其元素的自然順序對其進行排序。 * **`PriorityBlockingQueue(Collection c)`**：構造一個空隊列，其中包含指定集合中的元素。 * **`PriorityBlockingQueue(int initialCapacity)`**：構造具有指定初始容量的空隊列，該隊列根據其自然順序對其元素進行排序。 * **`PriorityBlockingQueue(int initialCapacity, Comparator comparator)`**：構造具有指定初始容量的空隊列，該隊列根據指定的比較器對其元素進行排序。 ## 4\. Java `PriorityBlockingQueue`方法 您應該知道`PriorityBlockingQueue`類下面提供了重要的方法。 * **`boolean add(object)`**：將指定的元素插入此優先級隊列。 * **`boolean offer(object)`**：將指定的元素插入此優先級隊列。 * **`boolean remove(object)`**：從此隊列中移除指定元素的單個實例（如果存在）。 * **`Object poll()`**：檢索并刪除此隊列的頭，如果有必要使元素可用，則等待指定的等待時間。 * **`Object poll(timeout, timeUnit)`**：檢索并刪除此隊列的開頭，并在必要時等待指定的等待時間以使元素可用。 * **`Object take()`**：檢索并刪除此隊列的頭，如有必要，請等待直到元素可用。 * **`void put(Object o)`**：將指定的元素插入此優先級隊列。 * **`void clear()`**：從此優先級隊列中刪除所有元素。 * **`Comparator comparator()`**：返回用于對此隊列中的元素進行排序的比較器；如果此隊列是根據其元素的自然順序排序的，則返回`null`。 * **`boolean contains(Object o)`**：如果此隊列包含指定的元素，則返回`true`。 * **`Iterator iterator()`**：在此隊列中的元素上返回一個迭代器。 * **`int size()`**：返回此隊列中的元素數。 * **`int drainTo(Collection c)`**：從此隊列中刪除所有可用元素，并將它們添加到給定的集合中。 * **`int drainTo(Collection c, int maxElements)`**：從此隊列中最多移除給定數量的可用元素，并將其添加到給定的集合中。 * **`int remainingCapacity()`**：由于`PriorityBlockingQueue`不受容量限制，因此始終返回`Integer.MAX_VALUE`。 * **`Object[] toArray()`**：返回包含此隊列中所有元素的數組。 > 請注意`take()`和`poll()`方法之間的**區別**。 `poll()`檢索并刪除此隊列的頭部，如果此隊列為空，則返回`null`。 它不阻止操作。 > > `take()`檢索并刪除此隊列的頭部，如有必要，請等待直到元素可用。 它正在阻止操作。 ## 5\. 總結 在此 **Java`PriorityBlockingQueue`教程**中，我們學習了使用`PriorityBlockingQueue`類的特性，該類可以按默認的自然順序或自定義順序（比較器）存儲元素。 我們還了解了`PriorityBlockingQueue`類的一些重要方法和[構造器](https://howtodoinjava.com/oops/java-constructors/)。 將我的問題放在評論部分。 學習愉快！ 參考文獻： [`PriorityBlockingQueue`類 Java 文檔](https://docs.oracle.com/javase/8/docs/api/java/util/PriorityBlockingQueue.html)