2. 程式人生 > >Java常見集合框架(十六)：Queue之DelayQueue、PriorityQueue、PriorityBlockingQueue

Java常見集合框架(十六)：Queue之DelayQueue、PriorityQueue、PriorityBlockingQueue

阿新 • • 發佈：2018-12-29

DelayQueue

public class DelayQueue extends AbstractQueue implements BlockingQueue

  1. Delayed 元素的一個基於優先順序的無界阻塞佇列，只有在延遲期滿時才能從中提取元素。
  2. 如果延遲都還沒有期滿，則佇列沒有頭部，並且 poll 將返回 null。
  3. 不允許使用 null 元素。

成員變數

    /**
     * 可重入的互斥鎖
     */
    private final transient ReentrantLock lock = new ReentrantLock();

    /**
     * 一個基於優先順序堆的無界優先順序佇列。可自然排序。不允許使用 null 元素。
     */
 

    private final PriorityQueue<E> q = new PriorityQueue<E>();

    /**
     * 喚醒或等待take執行緒的條件
     */
    private final Condition available = lock.newCondition();

構造方法

    /**
     * 建立一個最初為空的新 DelayQueue。
     */
    public DelayQueue() {}

    /**
     * 建立一個最初包含 Delayed 例項的給定 collection 元素的 DelayQueue。
     */
 

    public DelayQueue(Collection<? extends E> c) {
        this.addAll(c);
    }

常用方法

boolean add(E e)：將指定元素插入此延遲佇列中。

    public boolean add(E e) {
        return offer(e);
    }

boolean offer(E e)：將指定元素插入此延遲佇列。

    public boolean offer(E e) {
        final ReentrantLock lock
 
 = this.lock;
        lock.lock();//阻塞式獲取鎖
        try {
            E first = q.peek();//獲取但不移除此佇列的頭部；如果此佇列為空，則返回 null。
            q.offer(e);//將指定的元素插入此優先順序佇列。
            if (first == null || e.compareTo(first) < 0)
                available.signalAll();//佇列中無元素，喚醒take執行緒
            return true;
        } finally {
            lock.unlock();//釋放鎖
        }
    }

E peek()：獲取但不移除此佇列的頭部；如果此佇列為空，則返回 null。

    public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();//阻塞式獲取鎖
        try {
            return q.peek();// 獲取但不移除此佇列的頭；如果此佇列為空，則返回 null。
        } finally {
            lock.unlock();//釋放鎖
        }
    }

E poll()： 獲取並移除此佇列的頭，如果此佇列不包含具有已到期延遲時間的元素，則返回 null。

    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            E first = q.peek();//  獲取但不移除此佇列的頭；如果此佇列為空，則返回 null。
            //getDelay:返回與此物件相關的剩餘延遲時間，以給定的時間單位表示。
            if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
                return null;//佇列為空或元素未到期
            else {
                E x = q.poll();//獲取並移除此佇列的頭，如果此佇列為空，則返回 null。
                assert x != null;//非空校驗
                if (q.size() != 0)//佇列中還有元素
                    available.signalAll();//喚醒take執行緒
                return x;
            }
        } finally {
            lock.unlock();
        }
    }

void put(E e)：將指定元素插入此延遲佇列。

    public void put(E e) {
        offer(e);
    }

E take()：獲取並移除此佇列的頭部，在可從此佇列獲得到期延遲的元素之前一直等待（如有必要）。

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();//阻塞式獲取鎖，可響應執行緒中斷
        try {
            for (;;) {
                E first = q.peek();//獲取但不移除此佇列的頭；如果此佇列為空，則返回 null。
                if (first == null) {
                    available.await();//佇列為空，執行緒等待，釋放鎖
                } else {
                    long delay =  first.getDelay(TimeUnit.NANOSECONDS);//獲取元素剩餘到期市場，並判斷是否到期
                    if (delay > 0) {
                        long tl = available.awaitNanos(delay);//元素還未到期，執行緒等待指定時間，釋放鎖
                    } else {
                        E x = q.poll();//獲取並移除此佇列的頭，如果此佇列為空，則返回 null。
                        assert x != null;//非空校驗
                        if (q.size() != 0)
                            available.signalAll(); // 執行緒非空，喚醒其它所有take執行緒                        return x;//返回隊頭元素

                    }
                }
            }
        } finally {
            lock.unlock();//釋放鎖
        }
    }

由原始碼看出延遲佇列DelayQueue操作元素是通過PriorityQueue實現的，PriorityQueue是一個基於優先順序堆的無界優先順序佇列。利用可重入的互斥鎖ReentrantLock保證執行緒安全，同時利用Condition保證插入或獲取元素是阻塞的。

PriorityQueue

public class PriorityQueue extends AbstractQueue implements java.io.Serializable

  1. 一個基於優先順序堆的無界優先順序佇列。
  2. 優先順序佇列不允許使用 null 元素。
  3. 預設容量11，當元素容量小於64時，擴容double，否則擴容50%。
  4. 不是同步的。

成員變數

    /**
     * 初始容量
     */
    private static final int DEFAULT_INITIAL_CAPACITY = 11;

    /**
     * 元素以平衡二叉樹形式儲存
     */
    private transient Object[] queue;

    /**
     * 優先順序佇列元素數
     */
    private int size = 0;

    /**
     * 元素自然排序方式
     */
    private final Comparator<? super E> comparator;

    /**
     * 優先順序佇列修改次數
     */
    private transient int modCount = 0;

構造方法

    /**
     *  使用預設的初始容量（11），並根據其自然順序對元素進行排序。
     */
    public PriorityQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }

     /**
     * 使用指定的初始容量建立Queue，並根據指定的比較器對元素進行排序。
     */
    public PriorityQueue(int initialCapacity,
                         Comparator<? super E> comparator) {
        // Note: This restriction of at least one is not actually needed,
        // but continues for 1.5 compatibility
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.queue = new Object[initialCapacity];
        this.comparator = comparator;
    }

常用方法

boolean add(E e)：將指定的元素插入此優先順序佇列。

    public boolean add(E e) {
        return offer(e);
    }

boolean offer(E e)： 將指定的元素插入此優先順序佇列。

    public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        modCount++;//修改次數+1
        int i = size;
        if (i >= queue.length)
            grow(i + 1);//元素數可能不夠，需要擴容
        size = i + 1;
        if (i == 0)//佇列為空
            queue[0] = e;
        else
            siftUp(i, e);
        return true;
    }
     /**
     * 佇列擴容
     */
    private void grow(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
    int oldCapacity = queue.length;//獲取當前元素數
        // <64 雙倍擴容; >=64 擴容 50%
        int newCapacity = ((oldCapacity < 64)?
                           ((oldCapacity + 1) * 2):
                           ((oldCapacity / 2) * 3));
        if (newCapacity < 0) // overflow
            newCapacity = Integer.MAX_VALUE;//最大邊界
        if (newCapacity < minCapacity)
            newCapacity = minCapacity;
        queue = Arrays.copyOf(queue, newCapacity);//陣列複製
    }

    //選擇排序方式並插入相應位置
    private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }

    /**
     * Comparable 方式排序
     */
    private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (key.compareTo((E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = key;
    }

     /**
     * Comparator 方式排序
     */
    private void siftUpUsingComparator(int k, E x) {
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (comparator.compare(x, (E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = x;
    }

E peek()： 獲取但不移除此佇列的頭；如果此佇列為空，則返回 null。

    public E peek() {
        if (size == 0)
            return null;
        return (E) queue[0];
    }

E poll() ：獲取並移除此佇列的頭，如果此佇列為空，則返回 null。

    public E poll() {
        if (size == 0)
            return null;
        int s = --size;//更新元素數
        modCount++;//修改次數+1
        E result = (E) queue[0];//獲取佇列頭部元素
        E x = (E) queue[s];//獲取尾部元素
        queue[s] = null;//末尾置空
        if (s != 0)//佇列中還有元素
            siftDown(0, x);
        return result;
    }
    /**
     * 元素重新排序
     */
     private void siftDown(int k, E x) {
        if (comparator != null)
            siftDownUsingComparator(k, x);
        else
            siftDownComparable(k, x);
    }

    /**
     * Comparable方式重新排序
     */
    private void siftDownComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>)x;
        int half = size >>> 1;        // loop while a non-leaf
        while (k < half) {
            int child = (k << 1) + 1; // assume left child is least
            Object c = queue[child];
            int right = child + 1;
            if (right < size &&
                ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
                c = queue[child = right];
            if (key.compareTo((E) c) <= 0)
                break;
            queue[k] = c;
            k = child;
        }
        queue[k] = key;
    }

    /**
     * Comparator方式重新排序
     */
    private void siftDownUsingComparator(int k, E x) {
        int half = size >>> 1;
        while (k < half) {
            int child = (k << 1) + 1;
            Object c = queue[child];
            int right = child + 1;
            if (right < size &&
                comparator.compare((E) c, (E) queue[right]) > 0)
                c = queue[child = right];
            if (comparator.compare(x, (E) c) <= 0)
                break;
            queue[k] = c;
            k = child;
        }
        queue[k] = x;
    }

由原始碼看出，PriorityQueue是非執行緒安全的，利用Comparator或Comparable進行自然排序，從而實現有優先順序的佇列，以平衡二叉樹的形式儲存在transient Object[] queue中，雖然api中介紹說是無界佇列，但從原始碼看出其實是有邊界的 ，值為Integer.MAX_VALUE;只是邊界特別大，從某種程度上來說，可以理解為無邊界。

PriorityBlockingQueue

public class PriorityBlockingQueue extends AbstractQueue implements BlockingQueue, java.io.Serializable

  1. 一個無界阻塞佇列，它使用與類 PriorityQueue 相同的順序規則，並且提供了阻塞獲取操作。
  2. 此佇列邏輯上是無界的，但是資源被耗盡時試圖執行 add 操作也將失敗（導致 OutOfMemoryError）。
  3. 不允許使用 null 元素。
  4. 不允許插入不可比較的物件。

成員變數

    //元素操作均基於PriorityQueue
    private final PriorityQueue<E> q;
    //可重入的互斥鎖，該處採用公平鎖
    private final ReentrantLock lock = new ReentrantLock(true);
    //take條件
    private final Condition notEmpty = lock.newCondition();

構造方法

    /**
     * 用預設的初始容量 (11) 建立一個 PriorityBlockingQueue，並根據元素的自然順序對其元素進行排序。
     */
    public PriorityBlockingQueue() {
        q = new PriorityQueue<E>();
    }

    /**
     * 使用指定的初始容量建立一個 PriorityBlockingQueue，並根據指定的比較器對其元素進行排序。
     */
    public PriorityBlockingQueue(int initialCapacity,
                                 Comparator<? super E> comparator) {
        q = new PriorityQueue<E>(initialCapacity, comparator);
    }

    /**
     * 使用指定的初始容量建立一個 PriorityBlockingQueue，並根據元素的自然順序對其元素進行排序。
     */
    public PriorityBlockingQueue(int initialCapacity) {
        q = new PriorityQueue<E>(initialCapacity, null);
    }

    /**
     * 建立一個包含指定 collection 元素的 PriorityBlockingQueue。
     */
    public PriorityBlockingQueue(Collection<? extends E> c) {
        q = new PriorityQueue<E>(c);
    }

常用方法

boolean add(E e)：將指定元素插入此優先順序佇列。

    public boolean add(E e) {
        return offer(e);
    }

boolean offer(E e)：將指定元素插入此優先順序佇列。

    public boolean offer(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();//阻塞式獲取鎖
        try {
            boolean ok = q.offer(e);//插入元素
            assert ok;
            notEmpty.signal();//喚醒take執行緒
            return true;
        } finally {
            lock.unlock();//釋放鎖
        }
    }

E peek()：獲取但不移除此佇列的頭；如果此佇列為空，則返回 null。

    public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();//阻塞式獲取鎖
        try {
            return q.peek();//獲取元素
        } finally {
            lock.unlock();//釋放鎖
        }
    }

E poll()：獲取並移除此佇列的頭，如果此佇列為空，則返回 null。

    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();//阻塞式獲取鎖
        try {
            return q.poll();//獲取並移除此佇列的頭
        } finally {
            lock.unlock();//釋放鎖
        }
    }

E take()：獲取並移除此佇列的頭部，在元素變得可用之前一直等待（如果有必要）。

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();//阻塞式獲取鎖，可響應執行緒中斷
        try {
            try {
                while (q.size() == 0)
                    notEmpty.await();//佇列中無元素，阻塞等待，釋放鎖
            } catch (InterruptedException ie) {
                notEmpty.signal(); // propagate to non-interrupted thread
                throw ie;
            }
            E x = q.poll();//有元素，獲取並移除元素
            assert x != null;
            return x;//返回元素
        } finally {
            lock.unlock();//釋放鎖
        }
    }

void put(E e)：將指定元素插入此優先順序佇列。

    public void put(E e) {
        offer(e); // never need to block
    }

有原始碼看出，PriorityBlockingQueue是基於PriorityQueue實現具有優先順序的無界阻塞佇列，利用ReentrantLock實現執行緒安全，Condition實現阻塞。

DelayQueue及PriorityBlockingQueue實現具有優先順序的無界阻塞佇列都是基於PriorityQueue的，區別在於DelayQueue加入了延遲概念。雖說都是無界，但最大邊界為：Integer.MAX_VALUE。

相關推薦

Java常見集合框架(十六)：Queue之DelayQueue、PriorityQueue、PriorityBlockingQueue

DelayQueue public class DelayQueue extends AbstractQueue implements BlockingQueue Delayed 元素的一個基於優先順序的無界阻塞佇列，只有在延遲期滿時才能從中提取元

Java常見集合框架(二):Iterable、Collection(List、Set、Queue)、AbstractCollection

1.Iterable<T>      是Collection(List、Set、Queue)的頂級介面，api釋義：實現這個介面允許物件成為 "foreach" 語句的目標。  即可用於迭

Android學習筆記三十六：android之socket程式設計例項

注意點：註冊訪問的網路許可權；android中UI執行緒不能有訪問網路的操作，否則會報android.os.NetworkOnMainThreadException的異常 <uses-permission android:name="

Python語言學習講解十六：python之描述符__set__和__get__ 等解釋

注：每週一到週五都會進行相關Python基礎知識更新，歡迎大家提寶貴的意見 一、方法： 首先說下python中存在的幾種方法：物件方法、靜態方法、類方法等，歸屬權分別為obj、cls、cls 其實可以從他們的引數中就可以看的出來 物件方法引數中含有self,這個

Java基礎學習筆記十六 集合框架（二）

first 哈希 cat etag 基於 col 容器 處的 新元素 List List接口的特點: 它是一個元素存取有序的集合。例如，存元素的順序是11、22、33。那麽集合中，元素的存儲就是按照11、22、33的順序完成的。 它是一個帶有索引的集合，通過索引就

轉：【Java並發編程】之十六：深入Java內存模型——happen-before規則及其對DCL的分析（含代碼）

無需 bit 對象引用 說了 final 緩存 機器 通過 round 轉載請註明出處：http://blog.csdn.net/ns_code/article/details/17348313 happen—before規則介紹 Java語言中有一個“先行發生

Java學習筆記（十六）：static關鍵字

ima 關鍵字 static關鍵字 es2017 java學習筆記 sta com 筆記 nbsp Java學習筆記（十六）：static關鍵字

Java類集框架（六）：Stack及Properties子類、Collections工具類

Stack子類 在java.util包內可以利用stack類實現棧的功能。此類定義如下： public class Stack<E> extends Vector<E> Stack類常用方法： 方法 型別

【給小白看的Java教程】第二十六章，可勝列舉：列舉

###列舉的誕生歷史（瞭解） 在服裝行業，衣服的分類根據性別可以表示為三種情況：男裝、女裝、中性服裝。 private ? type； public void setType(? type){ this.type = type } 需求：定義一個變數來表

筆記十六：“點點點”就能做到的一款分散式爬蟲管理框架——Gerapy

       前言：在上兩篇部落格中，我們解決了大量資訊的爬取問題分散式爬蟲，用scrapy_redis把專案分別部署放到多個遠端伺服器上，提高了爬取資料的速度。又做到了使用scrapyd，在遠端伺服器上安裝scrapyd,啟動scrapyd服務，把scrapy專案通過scr

Java程式設計思想 第十六章：陣列

對陣列的看法，你可以建立並組裝他們，通過使用整形索引值可以訪問他們中的元素，並且他們的尺寸不能發生改變。 1. 陣列為什麼特殊 陣列與其他種類的容器之間的區別有三方面： 效率，陣列是效率最高的儲存和隨機訪問物件引用序列的方式。陣列就是一個簡單線性序列，使得元素訪

Java設計模式（十六）之行為型模式：迭代子模式

一、定義： 迭代器模式，就是提供一種方法訪問一個集合物件中的各個元素，而不暴露其內部的表示。在實際的開發過程中，我們可能需要針對不同的需求，可能需要以不同的方式來遍歷整個整合物件，但是我們不希望在聚合物件的抽象介面層中充斥著各種不同的遍歷操作。這個時候我們就需要這樣一種東西

Django框架（十六：上傳圖片到自定義目錄下）

如何將圖片上傳到自定義目錄下 upload_to: 在根目錄下(MEDIA_ROOT)要生成的目錄 MEDIA_ROOT: 只要上傳圖片，肯定要設定，用於指定圖片上傳的根目錄。可以設定在static下(static目錄的搜尋路徑，已經通過STATICFILES_

C#回顧學習筆記三十六：字典集合Dictionary

1.字典集合是什麼？字典集合本身像它名字那樣通俗易懂，也就是“根據**查找出**”。字典集合的格式通常是： Dictionary<鍵的型別,值的型別> dic = new Dictionary<鍵的型別,值的型別>(); Dictionary字典集合

黑馬程式設計師：Java基礎——集合框架之體系概述、共性方法與迭代器

------- Java EE培訓、java培訓、期待與您交流！ ---------- 1.體系概述     1.1 為什麼出現集合類？         面嚮物件語言對事物的體現都是以物件的形式，所

Java面試準備十六：資料庫——MySQL效能優化

這裡只是為了記錄，由於自身水平實在不怎麼樣，難免錯誤百出，有錯的地方還望大家多多指出，謝謝。 1. 為查詢快取優化你的查詢 大多數的MySQL伺服器都開啟了查詢快取。這是提高性最有效的方法之一，而且這是被MySQL的資料庫引擎處理的。當有很多相同的查

ABP原始碼分析二十六：核心框架中的一些其他功能

本文是ABP核心專案原始碼分析的最後一篇，介紹一些前面遺漏的功能 AbpSession AbpSession: 目前這個和CLR的Session沒有什麼直接的聯絡。當然可以自定義的去實現IAbpSession使之與CLR的Session關聯 IAbpSession：定義如下圖中的四個屬性。 NullA

Java併發程式設計系列之十六：Lock鎖

Lock鎖簡介 Lock鎖機制是JDK 5之後新增的鎖機制，不同於內建鎖，Lock鎖必須顯式宣告，並在合適的位置釋放鎖。Lock是一個介面，其由三個具體的實現：ReentrantLock、ReetrantReadWriteLock.ReadLock 和 Ree

性能測試三十六：內存溢出和jvm常見參數

空間 0ms 成功 mar 大量 ali mem .com 分享 堆內存溢出： 此種溢出，加內存只能緩解問題，不能根除問題，需優化代碼堆內存中存在大量對象，這些對象都有被引用，當所有對象占用空間達到堆內存的最大值，就會出現內存溢出OutOfMemory:Java h

java高階特性與實戰專案 第一章集合框架——課後作業：

  建立一個類Queue 代表隊列,新增add(Object o)及get()方法,並新增main方法進行驗證import java.util.LinkedList; public class Queue { LinkedList queue; public Que