Question

Java中是否有一个优先级队列，其行为类似于LinkedBlockingQueue？

PriorityBlockingQueue没有阻塞，因为它是无限制的。

Answer 1

您可以尝试 Google Guava 中的MinMaxPriorityQueue，并将最大尺寸设置为下一个：

Queue<User> users = Queues.synchronizedQueue(
    MinMaxPriorityQueue.orderedBy(userComparator)
       .maximumSize(1000)
       .create()
);

NB：由于MinMaxPriorityQueue不是线程安全的，您需要使用装饰器Queues.synchronizedQueue(Queue)，以使其线程安全。

当你需要一个BlockingQueue时，你必须自己实现装饰器，这并不难实现。

以下是它的样子：

public class SynchronizedBlockingQueue implements BlockingQueue {

    private final BlockingQueue queue;

    public SynchronizedBlockingQueue(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public synchronized boolean add(final Object o) {
        return this.queue.add(o);
    }

    @Override
    public synchronized boolean offer(final Object o) {
        return this.offer(o);
    }
    ...
}

然后，创建BlockingQueue的代码将是：

BlockingQueue<User> users = new SynchronizedBlockingQueue(
    MinMaxPriorityQueue.orderedBy(userComparator)
       .maximumSize(1000)
       .create()
);

Answer 2

如果您不需要全面的BlockingQueue接口实现，那么您可以使用Semaphore之类的东西（在Kotlin中）：

interface BlockingBag<E: Any> {
    @Throws(InterruptedException::class)
    fun put(element: E)
    @Throws(InterruptedException::class)
    fun take(): E
}
class BlockingPriorityBag<E: Any>(val capacity: Int) : BlockingBag<E> {
    init {
        require(capacity >= 1) { "$capacity must be 1 or greater" }
    }
    private val queue = PriorityBlockingQueue<E>()
    private val semaphore = Semaphore(capacity)
    override fun take(): E {
        val item = queue.take()
        semaphore.release()
        return item
    }
    override fun put(element: E) {
        semaphore.acquire()
        queue.put(element)
    }
}

BoundedPriorityBlockingQueue - 线程安全，阻塞和有界？

2 个答案: