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

最新推荐文章于 2022-01-24 16:23:23 发布
最新推荐文章于 2022-01-24 16:23:23 发布
阅读量767 收藏 2
点赞数
分类专栏： Java Java常见集合框架 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a355586533/article/details/78276149
版权

##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。

Believe勤能补拙
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA并发编程： PriorityQueue -》阻塞队列 PriorityBlockingQueue
开始写bug~~~
12-01 1160
生活 一旦一种新技术开始滚动碾压道路，如果你不能成为压路机的一部分，那么你就只能成为道路的一部分。 PriorityQueue 阻塞队列里的PriorityBlockingQueue基于PriorityQueue，所以在研究PriorityBlockingQueue之前要先研究一下PriorityQueue，这是一个有优先级概念的队列，是有顺序的，他的顺序是通过内部的比较器实现。 他的内部维护了一...
Java集合框架源码剖析：PriorityQueue
12-22
　前面以Java ArrayDeque为例讲解了Stack和Queue，其实还有一种特殊的队列叫做PriorityQueue，即优先队列。优先队列的作用是能保证每次取出的元素都是队列中权值小的（Java的优先队列每次取小元素，C++的优先队列...
并发容器学习—DelayQueue与PriorityBlockingQueue
weixin_34406796的博客
05-02 565
2019独角兽企业重金招聘Python工程师标准>>> ...
Java集合框架整理(四)——PriorityQueue、DelayQueue源码分析
hesheng1024的博客
06-05 368
title: Java集合框架整理(四)——PriorityQueue、DelayQueue源码分析 tag: Java 文章目录title: Java集合框架整理(四)——PriorityQueue、DelayQueue源码分析 tag: JavaPriorityQueue、DelayQueue源码分析PriorityQueue源码分析addpollpeek其他方法DelayQueue源码分析...
java同步阻塞队列之DelayQueue实现原理，PriorityQueue原理
LeoHan
01-24 467
DelayQueue是一种延迟队列，能够在指定的时间之后执行。其底层采用PriorityQueue作为底层数据结构。 在讲解DelayQueue之前，我们需要先讲解一下PriorityQueue。 PriorityQueue是一个优先级队列，在底层使用了一个可动态扩容的数组作为基础数据结构，实现了堆结构，默认是一个小顶堆。 public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Ser
PriorityBlockingQueue和DelayQueue队列剖析
binga的博客
11-08 434
目录PriorityBlockingQueue优先级阻塞队列DelayQueue延迟队列 在阻塞队列BlockingQueue数组和链表的实现中剖析了基于数组和链表的实现的阻塞队列，接下来来剖析一下与优先级相关的阻塞队列PriorityBlockingQueue和DelayQueue。在介绍之前需要了解优先级队列相关的知识，以下是优先级队列的相关知识链接： 源码阅读(12)：Java中主要的Queue、Deque结构——PriorityQueue集合（上） 源码阅读(13)：Java中主要的Queue、De
Java集合框架常见面试题.7z
12-03
以下是一些关于Java集合框架的常见面试题及对应的详细解释： 1. **什么是集合框架？** 集合框架是一系列接口和类的集合，它们提供了在Java中处理对象集合的统一方式。这些接口和类包括List、Set、Map等，以及它们...
Java复习之集合框架总结
08-29
Java集合框架是Java编程语言中用于存储和管理对象的核心组件，它提供了一组高效、灵活的数据结构和操作这些数据结构的方法。本篇文章将深入探讨Java集合框架的主要概念、设计原则以及常用的集合类。 首先，为什么...
JAVA集合框架专题
08-19
JAVA集合框架专题 JAVA集合框架是JAVA编程语言中的一种常用的数据结构，用于存储和操作对象信息。下面是JAVA集合框架的主要知识点： 一、集合框架概述 JAVA集合框架是一种容器，用于存储对象信息。所有集合类都...
Java核心知识体系6：集合框架详解.pdf
最新发布
11-17
Java集合框架是Java编程语言中不可或缺的一部分，它提供了一种高效、灵活的方式来存储和操作数据。集合框架的核心包括多个接口、抽象类以及实现类，它们共同构建了一个强大的数据结构网络。 1. **集合接口** - **...
java编程思想笔记-并发之DelayQueue和PriorityBlockingQueue
光与热的博客
08-12 447
DelayQueue是无界的BlockingQueue，用于防止实现了Delayed接口的对象，其中的对象只能在其到期时才能从队列中取走，这种队列是有序的且队头对象的延迟到期的时间越长。如果没有任何的延迟到期就不会有头元素，并且poll()将返回null 示例:class DelayedTask implements Runnable ,Delayed{ private static in
PriorityBlockingQueue和DelayQueue
weixin_41029286的博客
08-05 135
PriorityBlockingQueue PriorityQueue（优先级阻塞队列）是按照元素的优先级从小到大出队列的。正因为如此， PriorityQueue元素之间需要可以比较大小（使用PriorityBlockingQueue的Comparator，或者元素实现Comparable）。 public class PriorityBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E&gt
其他阻塞队列DelayQueue&PriorityBlockQueue延迟阻塞队列和优先级阻塞队列
wenhuaiteng的专栏
12-04 549
1. DelayQueue延迟阻塞队列。     该队列主要作用是延迟添加元素,mQueue,put(Delay) 2.DelayQueue实例        由于添加到DelayQueue的item延迟10s，所以调用take方法时候需要等待10秒才可以获取到，否则一直block阻塞状态。    DelayQueue mQueue = new DelayQueue(); //添
java中PriorityBlockingQueue 和DelayedWorkQueue 区别
weixin_34319374的博客
11-14 263
java中PriorityBlockingQueue 和DelayedWorkQueue 区别 转载于:https://www.cnblogs.com/zhangshiwen/p/9955759.html
java中priorityQueue类_Java中的PriorityBlockingQueue类
weixin_33481022的博客
02-27 105
Java中的PriorityBlockingQueue类具有一个具有无限功能的阻塞队列，并且基于具有相同排序规则的PriorityQueue类。PriorityBlockingQueue类是Java集合框架的一部分。演示此的程序如下所示-示例importjava.util.concurrent.PriorityBlockingQueue;publicclassDemo{publicsta...
并发队列：PriorityBlockingQueue和DelayQueue案例使用
duyabc的博客
02-05 289
目录 PriorityBlockingQueue使用 DelayQueue使用 总结 PriorityBlockingQueue使用 import java.util.concurrent.PriorityBlockingQueue; /** * @author ：jiaolian * @date ：Created in 2021-02-03 15:44 * @description：priorityBlockingQueue优先级队列测试 * @modified By： * 公众号
PriorityQueue和PriorityBlockingQueue
热门推荐
程序那些事
05-05 1万+
文章目录简介PriorityQueuePriorityBlockingQueue PriorityQueue和PriorityBlockingQueue 简介 Queue一般来说都是FIFO的，当然之前我们也介绍过Deque可以做为栈来使用。今天我们介绍一种PriorityQueue，可以安装对象的自然顺序或者自定义顺序在Queue中进行排序。 PriorityQueue 先看PriorityQu...
java常用类--DelayQueue
wuyundong123的博客
01-21 180
DelayQueue，顾名思义，延迟队列，可以设置延迟多久执行，从类注释上可以得到以下有用信息： 队列元素将在过期时被执行，越靠近对头，越早过期 未过期的元素不能被take 不允许空元素 一、类图说明 public class DelayQueue<E extends Delayed> extends AbstractQueue<E> implements...
【小家Java】Java优先队列PriorityQueue、PriorityBlockingQueue使用示例
架构师：通透，才能写出好代码！
04-26 1254
前言 我们知道队列是遵循先进先出（First-In-First-Out）模式的，但有些时候需要在队列中基于优先级处理对象。 为什么优先级队列，其实很好理解。比如银行的VIP客户、各大机场的VIP客户的优先登机等，都是优先级队列的体现。而正常排队的都属于普通队列~ PriorityQueue PriorityQueue类在Java1.5中引入的，它是Java集合框架的一部分。PriorityQueu...
Java集合框架：Queue接口详解与应用
"Queue方法-java技术及其应用第5章 收集与数据结构应用" 在Java编程中，收集框架（Collections Framework）是一个强大的工具，它提供了一系列接口、抽象类和具体类，用于高效地存储、管理和操作对象。本章重点讨论...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值