PriorityBlockingQueue+DelayQueue

最新推荐文章于 2023-10-20 22:53:12 发布
最新推荐文章于 2023-10-20 22:53:12 发布
阅读量55 收藏
点赞数
分类专栏： # JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_freshman/article/details/89357282
版权

java并发编程之美 学习笔记

PriorityBlockingQueue

PriorityBlockingQueue是带优先级的、无界的、阻塞队列，每次出队都返回优先级最高或者最低的元素。
结构

public class PriorityBlockingQueue<E> extends AbstractQueue<E>
    implements BlockingQueue<E>, java.io.Serializable {

    //默认容量为 11
    private static final int DEFAULT_INITIAL_CAPACITY = 11;

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    //存放队列元素
    private transient Object[] queue;

    //队列元素个数
   private transient int size;

    //优先级比较器
    private final Comparator<? super E> comparator;

   
    private final ReentrantLock lock;
    private final Condition notEmpty;

    /**
     * allocationspi nLock 是个自旋锁，其使用 CAS 操作来保证同时只有一个线程可以扩容队列
     * 0: 当前没有正在进行扩容
     * 1：当前正在进行扩容
     */
    private transient volatile int allocationSpinLock;


    private PriorityQueue<E> q;
}

初始化

 public PriorityBlockingQueue() {
        this(DEFAULT_INITIAL_CAPACITY, null);
    }

    public PriorityBlockingQueue(int initialCapacity) {
        this(initialCapacity, null);
    }


    public PriorityBlockingQueue(int initialCapacity,
                                 Comparator<? super E> comparator) {
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition();
        this.comparator = comparator;
        this.queue = new Object[initialCapacity];
    }


    public PriorityBlockingQueue(Collection<? extends E> c) {
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition();

        // 如果不知道是否已经排序，则为true, 表示需要进行排序操作
        boolean heapify = true; 

        // 如果必须筛选空值，则为true
        boolean screen = true;  


        if (c instanceof SortedSet<?>) {
            SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
            this.comparator = (Comparator<? super E>) ss.comparator();
            heapify = false;
        }
        else if (c instanceof PriorityBlockingQueue<?>) {
            PriorityBlockingQueue<? extends E> pq =
                (PriorityBlockingQueue<? extends E>) c;
            this.comparator = (Comparator<? super E>) pq.comparator();
            screen = false;
            if (pq.getClass() == PriorityBlockingQueue.class) // exact match
                heapify = false;
        }

        Object[] a = c.toArray();
        int n = a.length;
        // If c.toArray incorrectly doesn't return Object[], copy it.
        if (a.getClass() != Object[].class)
            a = Arrays.copyOf(a, n, Object[].class);


        if (screen && (n == 1 || this.comparator != null)) {
            for (int i = 0; i < n; ++i)
                if (a[i] == null)
                    throw new NullPointerException();
        }
        this.queue = a;
        this.size = n;
        if (heapify)
            heapify();
    }

offer

public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        //获取锁
        lock.lock();
        int n, cap;
        Object[] array;

        while ((n = size) >= (cap = (array = queue).length))
        	//1.如果元素个数 >= 队列容量 -- 扩容
            tryGrow(array, cap);

        try {
            Comparator<? super E> cmp = comparator;
            if (cmp == null)
            	//2.通过默认比较器
                siftUpComparable(n, e, array);
            else
            	//通过自定义比较器
                siftUpUsingComparator(n, e, array, cmp);
            //队列元素个数+1, 
            size = n + 1;

            //激活 notEmpty.await()的 一个线程
            notEmpty.signal();
        } finally {
        	//释放锁
            lock.unlock();
        }
        return true;
    }



    //1.队列扩容
    private void tryGrow(Object[] array, int oldCap) {
        lock.unlock(); //第一步释放锁

        Object[] newArray = null;
        //allocationSpinLock == 0 ,表示当前没有线程在进行扩容操作
        //cas操作更新 allocationSpinLock ，将其更新为1，表示已有线程在进行扩容操作。
        if (allocationSpinLock == 0 &&
            UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
                                     0, 1)) {
            try {
                int newCap = oldCap + ((oldCap < 64) ?
                                       (oldCap + 2) : // grow faster if small
                                       (oldCap >> 1));
                if (newCap - MAX_ARRAY_SIZE > 0) {    // possible overflow
                    int minCap = oldCap + 1;
                    if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
                        throw new OutOfMemoryError();
                    newCap = MAX_ARRAY_SIZE;
                }
                if (newCap > oldCap && queue == array)
                	//初始化newArray 大小
                    newArray = new Object[newCap];
            } finally {
                allocationSpinLock = 0;
            }
        }

        //方法第一行释放锁，导致会有多个线程进行tryGrow这段代码，
        //但是cas操作 保证只有一个线程会 初始化newArray 成功;
        //其他线程 执行到此时，若newArray == null,则让出cpu
        if (newArray == null) 
            Thread.yield();

        //重新上锁
        lock.lock();
        if (newArray != null && queue == array) {
            queue = newArray;
            //copy数组
            System.arraycopy(array, 0, newArray, 0, oldCap);
        }
    }
 	


 	//2.默认比较器
 	/*
 	 * @param k the position to fill
     * @param x the item to insert
     * @param array the heap array
     */
	 private static <T> void siftUpComparable(int k, T x, Object[] array) {
        Comparable<? super T> key = (Comparable<? super T>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = array[parent];
            if (key.compareTo((T) e) >= 0)
                break;
            array[k] = e;
            k = parent;
        }
        array[k] = key;
    }

put
put 操作内部调用的是 offer 操作 ，由 于是无界队列，所以不需要阻塞。

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

poll
poll 操作的作用是获取队列内部堆树的根节点元素，如果队列为空 ，则 返回 null 。

   public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return dequeue();
        } finally {
            lock.unlock();
        }
    }


    private E dequeue() {
        int n = size - 1;
        if (n < 0)
            return null;
        else {
            Object[] array = queue;
            E result = (E) array[0];
            E x = (E) array[n];
            array[n] = null;
            Comparator<? super E> cmp = comparator;
            if (cmp == null)
                siftDownComparable(0, x, array, n);
            else
                siftDownUsingComparator(0, x, array, n, cmp);
            size = n;
            return result;
        }
    }

    /*
     * @param k the position to fill
     * @param x the item to insert
     * @param array the heap array
     * @param n heap size
     */
    private static <T> void siftDownComparable(int k, T x, Object[] array,
                                               int n) {
        if (n > 0) {
            Comparable<? super T> key = (Comparable<? super T>)x;
            int half = n >>> 1;           // loop while a non-leaf
            while (k < half) {
                int child = (k << 1) + 1; // assume left child is least
                Object c = array[child];
                int right = child + 1;
                if (right < n &&
                    ((Comparable<? super T>) c).compareTo((T) array[right]) > 0)
                    c = array[child = right];
                if (key.compareTo((T) c) <= 0)
                    break;
                array[k] = c;
                k = child;
            }
            array[k] = key;
        }
    }

take
take 操作的作用是获取队列内部堆树的根节点元素 ， 如果队列为空则阻塞

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        E result;
        try {
            while ( (result = dequeue()) == null)
                notEmpty.await();
        } finally {
            lock.unlock();
        }
        return result;
    }

size
计算 队列元素个数 。 如下代码在返回 size 前加了锁，以保证在调用 size（） 方法时不会有其他线程进行入队和出队操作 。

    public int size() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return size;
        } finally {
            lock.unlock();
        }
    }

demo

例

public class PriorityBlockingQueueTest {
	static class MyTask implements Comparable<MyTask> {
		private int priority ;
		private String taskName;

		public MyTask(int priority, String taskName) {
			this.priority = priority;
			this.taskName = taskName;
		}

		public int getPriority() {
			return priority;
		}

		public void setPriority(int priority) {
			this.priority = priority;
		}

		public String getTaskName() {
			return taskName;
		}

		public void setTaskName(String taskName) {
			this.taskName = taskName;
		}

		@Override
		public int compareTo(MyTask o) {
			return this.priority - o.getPriority();
		}

		public void doSth(){
			System.out.println(taskName +" : " +priority);
		}
	}

	public static void main(String[] args) {
		PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<MyTask>();
		IntStream.rangeClosed(1,10).forEach(index -> {
			queue.add(new MyTask(new Random().nextInt(10), "TASK_" + index));
		});

		while(!queue.isEmpty()){
			MyTask task = queue.poll();
			if(task != null){
				task.doSth();
			}
		}

		System.out.println("=============END=============");
	}

}

运行结果:
在这里插入图片描述

从结果可知 ，任务执行的先后顺序和它们被放入队列的先后顺序没有关系，而是和它
们的优先级有关系。

DelayQueue

DelayQueue并发队列是 一个无界的、阻塞延迟队 列 ，队列中的每个元素都有个过期时间.当从队列获取元素时，只有过期元素才会出队列。队列头元素是最快要过期的元素。

结构

public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
    implements BlockingQueue<E> {

	// ReentrantLock 实现线程同步
	private final transient ReentrantLock lock = new ReentrantLock();
	
	//DelayQueue 内部使用 PriorityQueue 存放数据
	//队列里面的元素要实现 Delayed 接口
    private final PriorityQueue<E> q = new PriorityQueue<E>();

    private Thread leader = null;

    private final Condition available = lock.newCondition();
}

Delayed

//继承了Comparable接口： 通常使用delay来确定顺序优先级;
public interface Delayed extends Comparable<Delayed> {
	//获取当前元素还有多少过期时间
    long getDelay(TimeUnit unit);
}

例

public class DelayedQueueTest {
	static class DelayedEle implements Delayed {
		private final long delayTime ; //延迟时间
		private final long expire  ; //到期时间
		private String taskName  ; //任务名称

		public DelayedEle(long delayTime, String taskName) {
			this.delayTime = delayTime;
			this.taskName = taskName;

			expire = System.currentTimeMillis() + delayTime;
		}

		//剩余时间＝到期时间 － 当前时间
		@Override
		public long getDelay(TimeUnit unit) {
			return unit.convert(this.expire - System.currentTimeMillis(),TimeUnit.MILLISECONDS );
		}

		//优先级队列的 比较规则
		@Override
		public int compareTo(Delayed o) {
			return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
		}

		@Override
		public String toString() {
			return "DelayedEle{" +
					"delayTime=" + delayTime +
					", expire=" + expire +
					", taskName='" + taskName + '\'' +
					'}';
		}
	}

	public static void main(String[] args) throws InterruptedException {
		DelayQueue<DelayedEle> queue = new DelayQueue<>();
		IntStream.rangeClosed(1,10).forEach(index -> {
			queue.offer(new DelayedEle(new Random().nextInt(500), "TASK_" + index));
		});

		DelayedEle temp ;
		while((temp = queue.take()) != null){
			System.out.println(System.currentTimeMillis() + "-----" +temp);
		}
	}
}
伊布拉西莫
关注
专栏目录
Queue常用类解析之BlockingQueue（一）：PriorityBlockingQueue、DelayQueue和DelayedWorkQueue
翻身已碰头的博客
04-22 1836
Queue常用类解析之PriorityQueue Queue常用类解析之ConcurrentLinkedQueue 一、简介 BlockingQueue是concurrent包下的一个并发Queue的接口，称为阻塞队列。 与ConcurrentLinkedQueue通过CAS方式来实现并发不同，BlockingQueue的并发方案是阻塞等待。 Jdk为BlockingQueue提供了不少的实现类，...
Queue集合之PriorityBlockingQueue详解
乐乐的博客
01-05 3549
集合系列文章 文章目录集合系列文章前言1、PriorityBlockingQueue是什么？2、查看类图接口3.源码解析3.1 构造器3.2 offer操作3.2.1 扩容3.2.2 建堆算法3.2.3 图文解释3.3 poll操作3.3.1 dequeue出队源码3.3.2 siftDownComparable堆调整源码总结 前言 1、PriorityBlockingQueue是什么？ 集合中无界优先队列 priorityBlockingQueue内部使用堆算法保证每次出队都是优先级最高的元素，元素入
PriorityBlockingQueue和DelayQueue
weixin_41029286的博客
08-05 157
PriorityBlockingQueue PriorityQueue（优先级阻塞队列）是按照元素的优先级从小到大出队列的。正因为如此， PriorityQueue元素之间需要可以比较大小（使用PriorityBlockingQueue的Comparator，或者元素实现Comparable）。 public class PriorityBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E&gt
PriorityBlockingQueue和DelayQueue队列剖析
binga的博客
11-08 465
目录PriorityBlockingQueue优先级阻塞队列DelayQueue延迟队列 在阻塞队列BlockingQueue数组和链表的实现中剖析了基于数组和链表的实现的阻塞队列，接下来来剖析一下与优先级相关的阻塞队列PriorityBlockingQueue和DelayQueue。在介绍之前需要了解优先级队列相关的知识，以下是优先级队列的相关知识链接： 源码阅读(12)：Java中主要的Queue、Deque结构——PriorityQueue集合（上） 源码阅读(13)：Java中主要的Queue、De
并发 Queue，ConcurrentLinkedQueue，BlockingQueue，PriorityBlockingQueue，DelayQueue
wjf_jone的博客
10-18 271
在并发队列上 JDK 提供了两套实现，一个是以 ConcurrentLinkedQueue 为代表的高性能队列，一个是以 BlockingQueue 接口为代表的阻塞队列，无论哪种都继承自 Queue。 ConcurrentLinkedQueue 这是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能， 通常 ConcurrentLinkedQueue 性能好于 BlockingQueue。它是一个基于链接节点的无界 线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的，尾是最
011-多线程-JUC集合-Queue-PriorityBlockingQueue和DelayQueue
dilv4062的博客
07-04 109
一、PriorityBlockingQueue简介 　　PriorityBlockingQueue是一个支持优先级的无界阻塞队列。默认情况下元素采用自然顺序升序排列。也可以自定义类实现compareTo()方法来指定元素排序规则，或者初始化PriorityBlockingQueue时，指定构造参数Comparator来对元素进行排序。但需要注意的是不能保证同优先级元素的顺序。 二、D...
深入探究LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue、DelayQueue源码
沐雨橙风ιε的博客
08-19 301
深入探究LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue、DelayQueue源码
10-Java多线程-4、并发容器-PriorityBlockingQueue和DelayQueue
my_momo_csdn的博客
03-06 917
并发容器 文章目录并发容器一、支持优先级的并发容器PriorityBlockingQueue ：支持优先级排序的无界阻塞队列DelayQueue：使用优先级队列实现的无界阻塞队列。二、数据结构2.1 二叉堆2.2 插入元素2.3 删除元素三、PriorityBlockingQueue3.1核心属性：2.2 构造方法默认自然排序2.3 入列操作add：队尾添加，有返回值，不会阻塞put: 队尾添加，...
四、ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue和DelayQueue学习总结
lovesman的博客
08-31 603
wdew
Delayqueue
10-20
DelayQueue是Java中的一个无界阻塞队列，它通过PriorityBlockingQueue实现延迟获取元素的功能。在DelayQueue中添加的元素必须实现Delayed接口，该接口指定了元素的延迟时间，只有在延迟期满后才能从队列中提取元素。...
delayqueue
07-28
DelayQueue是一个通过PriorityBlockingQueue实现延迟获取元素的无界阻塞队列。在DelayQueue中添加的元素必须实现Delayed接口，并且只有在延迟期满后才能从队列中提取元素。\[2\]DelayQueue常用于需要延迟处理任务的...
图解DelayQueue源码（java 8）——延时队列的小九九
every__day的博客
02-16 993
DelayQueue 源码解析，用画图的方式，讲明白延时队列的工作原理。
并发编程-延时队列DelayQueue
weixin_43874650的博客
10-20 249
在实现一个延迟订单的场景中，我们可以定义一个 Order 类，其中包含订单的基本信息，例如订单编 号、订单金额、订单创建时间等。在 getDelay 方法中，我们可以计算订单的剩余延迟时间，而在 compareTo 方法 中，我们可以根据订单的延迟时间进行比较。如果没有过期，也就是说剩余时间还存在，则先获取Leader对象，如果Leader已经有线程在处理，则当前线程进 行无限期等待，如果Leader为空，则首先将Leader设置为当前线程，并且让当前线程等待剩余时间。
用于项目样式reset的资源
11-03
用于项目样式reset的资源
pytz-2016.10.tar.bz2
最新发布
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
VB程序实例-判断键盘按下的键值.zip
11-03
VB程序实例-判断键盘按下的键值.zip
VB程序实例-控制其他程序成为自己的子窗体.zip
11-03
VB程序实例-控制其他程序成为自己的子窗体.zip
VB程序实例85_控件应用_输入序列号.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
springboot032-大学生就业信息管理系统.zip
11-03
项目资源包含：可运行源码+sql文件 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 项目具有较高的学习借鉴价值，也可拿来修改、二次开发。 有任何使用上的问题，欢迎随时与博主沟通，博主看到后会第一时间及时解答。 开发语言：Java 框架：springboot 技术：Vue JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7（一定要5.7版本） 数据库工具：Navicat11 开发软件：eclipse/myeclipse/idea Maven包：Maven3.3.9 系统是一个很好的项目，结合了后端服务（SpringBoot）和前端用户界面（Vue.js）技术，实现了前后端分离。 后台路径地址：localhost:8080/项目名称/admin/dist/index.html 前台路径地址：localhost:8080/项目名称/front/index.html
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值