JDK容器与并发—Queue—PriorityBlockingQueue

最新推荐文章于 2024-07-28 16:05:05 发布
最新推荐文章于 2024-07-28 16:05:05 发布
阅读量2.1k 收藏
点赞数
分类专栏： JDK容器与并发 文章标签： jdk容器 并发 PriorityBlockingQueu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Architect0719/article/details/51166764
版权

概述

      基于优先堆的无界阻塞队列，PriorityQueue的线程安全版本。

数据结构

      基于数组的平衡二叉堆，在PriorityQueue基础上，增加了一把锁、一个条件：

private transient Object[] queue;

// 增删查公用的锁
private final ReentrantLock lock;

// 队列为空时，阻塞take/poll线程的条件
private final Condition notEmpty;

 // 自旋锁，用CAS方式获取，用于动态扩展queue
private transient volatile int allocationSpinLock;

构造器

      与PriorityQueue几乎一样，除了需要对lock、notEmpty初始化：

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();		// lock、notEmpty初始化
	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();
	boolean heapify = true; // true if not known to be in heap order
	boolean screen = true;  // true if must screen for nulls
	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();
}

增删查

容器调整策略（避免无限制扩展）

      步骤（与PriorityQueue大致相同，除了采用自旋锁的方式动态分配数组，在获取公用锁下复制queue）：
1）当queue已满，若有元素入队请求，则进行容量扩展；
2）在获取公用锁lock的前提下，释放lock，采用自旋锁的方式动态扩展数组，允许与take/poll线程并发，完成分配后再重新获取lock；
3）oldCap小于64则容量翻倍；否则增长50%；
4）检查newCap是否在MAX_ARRAY_SIZE范围内，若minCap有overflow或大于MAX_ARRAY_SIZE，抛出OutOfMemoryError异常；否则容量最大不超过MAX_ARRAY_SIZE；
5）动态分配新容量的Object[]；
6）获取公用锁，将旧queue中的元素复制过来。

while ((n = size) >= (cap = (array = queue).length)) // while使用是为了采用自旋锁进行扩展queue
		tryGrow(array, cap);

// 动态扩展queue		
// 释放公用锁，采用自旋锁，允许扩展过程中与take/poll线程并发，避免其在该过程中的等待
private void tryGrow(Object[] array, int oldCap) {
	lock.unlock(); 				// 释放公用锁
	Object[] newArray = null;
	if (allocationSpinLock == 0 &&				// 采用CAS方式获取allocationSpinLock，进行动态分配
		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 = new Object[newCap];
		} finally {
			allocationSpinLock = 0;
		}
	}
	if (newArray == null) // 其他线程正进行扩展，当前线程yield
		Thread.yield();
	lock.lock();			    // 重新获取公用锁
	if (newArray != null && queue == array) {      // 复制队列
		queue = newArray;
		System.arraycopy(array, 0, newArray, 0, oldCap);
	}
}

基础方法

      与PriorityQueue一样，除了增加两个参数：Object[] array、Comparator<? super T> cmp，以保证并发性：

// 对元素x，从k往前移，保持二叉堆的平衡性
private static <T> void siftUpUsingComparator(int k, T x, Object[] array,
								   Comparator<? super T> cmp) {
	while (k > 0) {
		int parent = (k - 1) >>> 1;
		Object e = array[parent];
		if (cmp.compare(x, (T) e) >= 0)
			break;
		array[k] = e;
		k = parent;
	}
	array[k] = x;
}

// 对元素x，从k往后移，保持二叉堆的平衡性
private static <T> void siftDownUsingComparator(int k, T x, Object[] array,
												int n,
												Comparator<? super T> cmp) {
	if (n > 0) {
		int half = n >>> 1;
		while (k < half) {
			int child = (k << 1) + 1;
			Object c = array[child];
			int right = child + 1;
			if (right < n && cmp.compare((T) c, (T) array[right]) > 0)
				c = array[child = right];
			if (cmp.compare(x, (T) c) <= 0)
				break;
			array[k] = c;
			k = child;
		}
		array[k] = x;
	}
}

增

      步骤（过程与PriorityQueue一样，除了考虑并发性加锁）：
1）获取公用锁lock；
2）检查队列是否已满，若满则采用自旋锁的方式进行容量扩展；
3）从队尾，对元素进行siftUp，保持二叉堆的平衡性；
4）向take/poll线程发送notEmpty信号；
5）释放锁lock；
6）返回true。

另外，由于PriorityBlockingQueue无界，add、put操作都直接委托给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))
		tryGrow(array, cap);
	try {
		Comparator<? super E> cmp = comparator;
		if (cmp == null)
			siftUpComparable(n, e, array);
		else
			siftUpUsingComparator(n, e, array, cmp);
		size = n + 1;
		notEmpty.signal();
	} finally {
		lock.unlock();
	}
	return true;
}

删

步骤（过程与PriorityQueue一样，除了考虑并发性加锁）：
1）获取公用锁lock；
2）检查队列是否为空，为空则返回null；
3）取出队列最后一个元素，从索引0开始，对其进行siftDown，保持二叉堆的平衡性；
4）释放锁lock；
5）返回队首元素值。

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

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;
}

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
	long nanos = unit.toNanos(timeout);
	final ReentrantLock lock = this.lock;
	lock.lockInterruptibly();
	E result;
	try {
		while ( (result = dequeue()) == null && nanos > 0)
			nanos = notEmpty.awaitNanos(nanos);
	} finally {
		lock.unlock();
	}
	return result;
}

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;
	}
}

查

      步骤（过程与PriorityQueue一样，除了考虑并发性加锁）：
1）获取公用锁lock；
2）检查队列是否为空，为空则返回null；
3）释放锁lock；
4）返回队首元素值。

public E peek() {
	final ReentrantLock lock = this.lock;
	lock.lock();
	try {
		return (size == 0) ? null : (E) queue[0];
	} finally {
		lock.unlock();
	}
}

迭代器

      不保证元素的迭代顺序，基于底层数组的副本实现：

public Iterator<E> iterator() {
	return new Itr(toArray());
}

final class Itr implements Iterator<E> {
	final Object[] array; // Array of all elements
	int cursor;           // index of next element to return
	int lastRet;          // index of last element, or -1 if no such

	Itr(Object[] array) {
		lastRet = -1;
		this.array = array;
	}

	public boolean hasNext() {
		return cursor < array.length;
	}

	public E next() {
		if (cursor >= array.length)
			throw new NoSuchElementException();
		lastRet = cursor;
		return (E)array[cursor++];
	}

	public void remove() {
		if (lastRet < 0)
			throw new IllegalStateException();
		removeEQ(array[lastRet]);
		lastRet = -1;
	}
}

特性

PriorityBlockingQueue中优先级相同的元素处理

      若多个元素的优先级相同，则其顺序是不固定的，可以采用二级比较方法来进一步排序，以下示例为按照元素的入队顺序进行二级比较：

class FIFOEntry<E extends Comparable<? super E>>
		implements Comparable<FIFOEntry<E>> {
	static final AtomicLong seq = new AtomicLong(0);
	final long seqNum;
	final E entry;
	public FIFOEntry(E entry) {
		seqNum = seq.getAndIncrement();
		this.entry = entry;
	}
	public E getEntry() { return entry; }
	public int compareTo(FIFOEntry<E> other) {
		int res = entry.compareTo(other.entry);
		if (res == 0 && other.entry != this.entry)
			res = (seqNum < other.seqNum ? -1 : 1);
		return res;
	}
}

为什么PriorityBlockingQueue的操作不直接在委托给PriorityQueue基础上加锁实现？

      allocationSpinLock在动态扩展queue上的使用使得委托+lock是实现不了的。

PriorityBlockingQueue就是PriorityQueue的加锁线程安全版。

Architect0719
关注
专栏目录
【java】 java 优先级 队列 PriorityBlockingQueue
九师兄
04-23 681
1.概述 基于优先级的无界阻塞队列（优先级的判断通过构造函数传入的Compator对象来决定），内部控制线程同步的锁采用的是非公平锁。 网上大部分博客上PriorityBlockingQueue为公平锁，其实是不对的，查阅源码 public PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator) { this.l.
【Java多线程】JUC之并发容器—深入剖析并发队列PriorityBlockingQueue(五)
墩墩分墩
03-09 650
- **PriorityBlockingQueue**： 使用`基于数组的二叉堆`实现的，支持**按优先级排序**的`无界阻塞队列（其实就是线程安全的PriorityQueue）`，`写入的对象必须实现Comparable接口，或在队列构造方法传入比较器Comparator`。**默认按照自然顺序升序排序**，*缺点是不能保证同优先级元素的顺序*。**内部使用ReentrantLock和Condition实现** - 底层是一种基于`数组`实现的**堆结构**，是真正的无界队列`（仅受内存大小限制） `
JDK并发工具类源码学习系列——PriorityBlockingQueue
收拾心灵_描绘未来
11-20 4603
PriorityBlockingQueue是一个基于优先级堆的无界的并发安全的优先级队列（FIFO），队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法。实现原理PriorityBlockingQueue通过使用堆这种数据结构实现将队列中的元素按照某种排序规则进行排序，从而改变先进先出的队列顺序，提供开发者改变队列中元素的顺序的能力
java集合之PriorityBlockingQueue
最新发布
qq_22717543的博客
07-28 301
PriorityBlockingQueue是一个阻塞队列，它是有界的，有最大容量，一般达不到，虽然它是队列，它并不能满足先进先出规则，它是按优先级出队，它会将插入的数据进行排序，按优先级出队，底层采用数组实现的二叉堆，所以当我们往队列中添加自定义对象时，自定义对象需要实现Comparable接口，也就是需要告诉队列，你的数据需要按什么规则进行排序。具体情况，我们根据源码来解释。
JDK8 PriorityBlockingQueue(Collection＜? extends E＞ c)构造器 源码解析
anlian523的博客
08-05 439
PriorityBlockingQueue的这个(Collection<? extends E> c)重载版本构造器的源码有几个地方有点难懂，但本文讲述内容不是PriorityBlockingQueue的重点理解内容，所以本文单独讲解。
Java中的PriorityBlockingQueue
最佳 Java 编程
06-12 759
介绍： Java中的PriorityBlockingQueue实现了BlockingQueue接口并支持PriorityQueue的功能。 那么，什么是BlockingQueue？ 以下适用于BlockingQueue的任何实现： 尝试检索元素时，如果队列为空，线程将等待 在有限制的BlockingQueue实现的情况下，线程将等待直到它有空间插入新元素 Priority...
【死磕Java并发】-----J.U.C之阻塞队列：PriorityBlockingQueue
chenssy 的技术博客
07-31 6568
原文出处http://cmsblogs.com/ 『chenssy』 我们知道线程Thread可以调用setPriority(int newPriority)来设置优先级的，线程优先级高的线程先执行，优先级低的后执行。而前面介绍的ArrayBlockingQueue、LinkedBlockingQueue都是采用FIFO原则来确定线程执行的先后顺序，那么有没有一个队列可以支持优先级呢？ Priori
同步类容器和并发类容器
热门推荐
yjclsx的博客
07-31 41万+
一.为什么会出现同步容器？ 在Java的集合容器框架中，主要有四大类别：List、Set、Queue、Map。 注意Collection和Map是顶层接口，而List、Set、Queue接口则分别继承了Collection接口，分别代表数组、集合和队列这三大类容器。 像ArrayList、LinkedList都是实现了List接口，HashSet实现了Set接口，而Deque（双向队列，允许...
并发容器的原理，7大并发容器详解、及使用场景
11-15
5. LinkedBlockingQueue、ArrayBlockingQueue 和 PriorityBlockingQueue 是阻塞队列的实现，扩展了 Queue 接口，支持阻塞的插入和获取操作。它们分别基于链表、数组和优先级堆实现，其中 ArrayBlockingQueue 和 ...
Java并发编程：同步容器、并发容器和阻塞队列
Mook的博客
07-02 1236
为了方便编写出线程安全的程序，Java里面提供了一些线程安全类和并发工具，比如：同步容器、并发容器、阻塞队列、Synchronizer（比如CountDownLatch）。一.为什么会出现同步容器在Java的集合容器框架中，主要有四大类别：List、Set、Queue、Map。如果有多个线程并发地访问这些容器时，就会出现问题。因此，在编写程序时，必须要求程序员手动地在任何访问到这些容器的地方进行同步
JAVA多线程基础 之十一 并发队列Queue
haponchang的博客
05-23 3784
并发队列Queue 在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能非阻塞队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。 下面这张图是 Java 并发类库提供的各种各样的线程安全队列实现，注意，图中并未将非线程安全部分包含进来。 Queue 阻塞队列与非阻塞队列 阻塞队列与普通队列的区别在...
JDK源码分析-PriorityBlockingQueue
WriteOnRead
08-14 245
概述前文「JDK源码分析-PriorityQueue」分析了优先队列 PriorityQueue，它既不是阻塞队列，而且线程不安全。本文分析线程安全的阻塞优先队列 Pri...
Java同步数据结构之PriorityBlockingQueue
weixin_30721899的博客
01-29 187
前言 接下来继续BlockingQueue的另一个实现，优先级阻塞队列PriorityBlockingQueue。PriorityBlockingQueue是一个无限容量的阻塞队列，由于容量是无限的所以put等入队操作其实不存在阻塞，只要内存足够都能够立即入队成功，当然多个入队操作的线程之间还是存在竞争唯一锁的互斥访问。虽然PriorityBlockingQueue逻辑上是无界的，但是尝试添加元...
java中priorityQueue类_Java中的PriorityBlockingQueue类
weixin_33481022的博客
02-27 119
Java中的PriorityBlockingQueue类具有一个具有无限功能的阻塞队列，并且基于具有相同排序规则的PriorityQueue类。PriorityBlockingQueue类是Java集合框架的一部分。演示此的程序如下所示-示例importjava.util.concurrent.PriorityBlockingQueue;publicclassDemo{publicsta...
PriorityBlockingQueue源码分析JDK1.8
qq_39241239的博客
04-24 248
1.PriorityBlockingQueue概述 1.1PriorityBlockingQueue 能解决什么问题？什么时候使用 PriorityBlockingQueue? PriorityBlockingQueue 是基于优先级堆实现的线程安全的、无界、优先级、阻塞队列。 队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序。 在并发场景下，需要...
PriorityBlockingQueue
qq_43843037的博客
09-14 207
特性 public class PriorityBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {} PriorityBlockingQueue是一个支持优先级的无界阻塞队列，即队列里的数据可根据自定义的优先级顺序在队列中浮动。 基本属性 底层是数组,平衡二叉树堆的实现 // 默认容量为11 private static fin
PriorityQueue和PriorityBlockingQueue
程序那些事
05-05 1万+
文章目录简介PriorityQueuePriorityBlockingQueue PriorityQueue和PriorityBlockingQueue 简介 Queue一般来说都是FIFO的，当然之前我们也介绍过Deque可以做为栈来使用。今天我们介绍一种PriorityQueue，可以安装对象的自然顺序或者自定义顺序在Queue中进行排序。 PriorityQueue 先看PriorityQu...
Java-并发-队列-PriorityBlockingQueue
迷路剑客个人博客
11-24 646
Java-并发-队列-PriorityBlockingQueue 0x01 摘要 PriorityBlockingQueue是优先级阻塞队列，本文简要分析下。 0x02 简介 PriorityBlockingQueue特点如下： 支持优先级 无界阻塞队列 PriorityBlockingQueue 是无界队列，不会“队满”。实际当到达队列最大值后（Integer.MAX_VALUE - 8，减8...
深入理解Java并发：JDK并发包1工具与容器详解
总结来说，本文将全面剖析Java高并发JDK并发包1中的核心知识点，帮助读者掌握如何有效地利用这些工具和容器提升应用程序的并发性能和线程安全性。无论是初学者还是高级开发人员，都能从中找到有价值的信息，以便在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值