.NET 4.0 中似乎有很多与并发相关的改进，这些改进可能依赖于并发优先级队列。框架内是否有体面的优先级队列实现可供重用？
【问题讨论】：
标签： c# .net concurrency
在 msdn 上，作为“使用 .NET Framework 进行并行编程的示例”的一部分，有一个实现。见ParallelExtensionsExtras。
文件ConcurrentPriorityQueue.cs源代码的直接链接
【讨论】：
您可能需要自己动手。一个相对简单的方法是有一个规则队列数组，优先级降低。
基本上，您将插入队列以获得适当的优先级。然后，在消费者方面，您将沿着列表向下，从最高优先级到最低优先级，检查队列是否非空，如果是，则使用一个条目。
【讨论】：
也许您可以使用我自己的 PriorityQueue 实现。它实现了比通常的 push/pop/peek 更多的功能，每当我发现需要它时我就实现了这些功能。它还具有并发锁。
非常感谢您对代码的评论:)
public class PriorityQueue<T> where T : class
{
private readonly object lockObject = new object();
private readonly SortedList<int, Queue<T>> list = new SortedList<int, Queue<T>>();
public int Count
{
get
{
lock (this.lockObject)
{
return list.Sum(keyValuePair => keyValuePair.Value.Count);
}
}
}
public void Push(int priority, T item)
{
lock (this.lockObject)
{
if (!this.list.ContainsKey(priority))
this.list.Add(priority, new Queue<T>());
this.list[priority].Enqueue(item);
}
}
public T Pop()
{
lock (this.lockObject)
{
if (this.list.Count > 0)
{
T obj = this.list.First().Value.Dequeue();
if (this.list.First().Value.Count == 0)
this.list.Remove(this.list.First().Key);
return obj;
}
}
return null;
}
public T PopPriority(int priority)
{
lock (this.lockObject)
{
if (this.list.ContainsKey(priority))
{
T obj = this.list[priority].Dequeue();
if (this.list[priority].Count == 0)
this.list.Remove(priority);
return obj;
}
}
return null;
}
public IEnumerable<T> PopAllPriority(int priority)
{
List<T> ret = new List<T>();
lock(this.lockObject)
{
if (this.list.ContainsKey(priority))
{
while(this.list.ContainsKey(priority) && this.list[priority].Count > 0)
ret.Add(PopPriority(priority));
return ret;
}
}
return ret;
}
public T Peek()
{
lock (this.lockObject)
{
if (this.list.Count > 0)
return this.list.First().Value.Peek();
}
return null;
}
public IEnumerable<T> PeekAll()
{
List<T> ret = new List<T>();
lock (this.lockObject)
{
foreach (KeyValuePair<int, Queue<T>> keyValuePair in list)
ret.AddRange(keyValuePair.Value.AsEnumerable());
}
return ret;
}
public IEnumerable<T> PopAll()
{
List<T> ret = new List<T>();
lock (this.lockObject)
{
while (this.list.Count > 0)
ret.Add(Pop());
}
return ret;
}
}
【讨论】：
嗯，7 年过去了，但为了后代，我想用我的实现来回答。
Documentation: Optionally awaitable simple to use Concurrent Priority Queue
【讨论】：
由于所有当前答案都已过时或不提供可行的解决方案，因此有一个可用的 implementation on MSDN。请注意，在此实现中优先处理较低的优先级。
【讨论】：
检查Thread-safe Collections in .NET Framework 4 and Their Performance Characteristics 但AFAIK 没有准备好使用的优先级队列。所有新的线程安全集合都不会维护顺序，但您可以在它们之上创建自己的集合。检查@Steven 的方式。
【讨论】：
选项：
1) 如果您的队列永远不会变大，请使用堆并为每次插入和删除锁定整个结构。
2) 如果你的队列会变大，你可以使用这样的算法：
http://www.research.ibm.com/people/m/michael/ipl-1996.pdf
该算法允许多个线程同时处理堆结构，而不会因为一次支持只对树的一部分进行细粒度锁定而面临损坏或死锁的风险。您必须进行基准测试，看看额外锁定和解锁操作的开销是否比锁定整个堆的争用成本更高。
3) 如果您的目标是完全避免锁定，则上面链接中提到的另一种算法建议使用 FIFO 请求队列（无需锁定即可轻松实现）和一个单独的线程，这是唯一接触堆的东西.您必须进行测量，以了解使用同步对象在线程之间切换焦点的开销与普通直接锁定的开销相比如何。
在您开始之前，有必要了解一下在使用锁定的简单实现上的命中有多糟糕。它可能不是最有效的实现，但如果它的执行速度仍然比您需要的速度快几个数量级，那么维护的便利性（也就是说，任何人，包括您现在一年都可以，能够简单地查看代码并了解它的作用）可能会超过在排队机制中占用的 CPU 时间的一小部分。
希望这会有所帮助:-)
【讨论】：
最近，我正在创建一个需要时间戳事件的状态机。我需要有自己的 ID 的定时事件，而不仅仅是一个简单的时钟滴答声，这样我就可以区分一个事件和另一个事件。
研究这个问题让我想到了使用优先级队列。我可以以任何顺序将定时事件及其信息排入队列；优先级队列将负责正确地对事件进行排序。计时器将定期检查优先级队列，以查看是否到了队列头部的事件触发的时间。如果是这样，它将使事件出队并调用与其关联的委托。这种方法正是我想要的。
在 CodeProject 上搜索
https://www.codeproject.com/Articles/13295/A-Priority-Queue-in-C
我发现已经编写了一个优先级队列[^] 类。但是，我突然想到，我可以使用我的老朋友跳过列表轻松编写自己的内容。这样做的好处是出队操作只需要 O(1) 时间，而入队操作平均仍然是 log(n)。我认为以这种方式使用跳过列表很新颖，值得单独写一篇文章。
原来如此。我希望你觉得它很有趣。
【讨论】：
我找到了并发优先级队列here 的一个很好的例子。 希望对你有一点帮助。
var priorityQueue = new ConcurrentPriorityQueue<TKey, TValue>();
TKey 可以是 int 值或任何其他实现 IComparable 的对象。
要使用这样的队列，您可以执行以下操作：
var priorityQueue = new ConcurrentPriorityQueue<int, object>();
// Add elements
priorityQueue.Enqueue(2, elementP2);
priorityQueue.Enqueue(1, elementP1);
// Here you will receive elementP1
bool result = priorityQueue.TryDequeue(out KeyValuePair<int, object> element);
【讨论】：