Question

我需要为游戏服务器上的消息实现FIFO队列，因此它需要尽可能快。每个用户都会有一个队列。

队列将具有maxiumem大小（比方说2000）。在运行期间，大小不会改变。

如果队列达到最大大小，我需要优先处理消息，方法是在添加新消息之前向后工作并删除较低优先级的消息（如果存在）。

优先级是一个int，可能的值为1,3,5,7,10。

可能有多条消息具有相同的优先级。

分配后，消息无法更改其优先级。

应用程序是异步的，因此需要锁定对队列的访问。

我目前正在使用LinkedList作为底层存储来实现它，但是担心搜索和删除节点会将其锁定太长时间。

这是我目前的基本代码：

public class ActionQueue
{
    private LinkedList<ClientAction> _actions = new LinkedList<ClientAction>();
    private int _maxSize;

    /// <summary>
    /// Initializes a new instance of the ActionQueue class.
    /// </summary>
    public ActionQueue(int maxSize)
    {
        _maxSize = maxSize;
    }

    public int Count
    {
        get { return _actions.Count; }            
    }

    public void Enqueue(ClientAction action)
    {
        lock (_actions)
        {
            if (Count < _maxSize)
                _actions.AddLast(action);
            else
            {
                LinkedListNode<ClientAction> node = _actions.Last;
                while (node != null)
                {
                    if (node.Value.Priority < action.Priority)
                    {
                        _actions.Remove(node);
                        _actions.AddLast(action);
                        break;
                    }

                    node = node.Previous;

                }                    
            }
        }
    }

    public ClientAction Dequeue()
    {
        ClientAction action = null;

        lock (_actions)
        {
            action = _actions.First.Value;
            _actions.RemoveFirst();
        }

        return action;
    }

}

Answer 1

可以在C5.IntervalHeap<T>类的C5 Generic Collection Library中找到C＃/。NET优先级队列的审核实现。

Answer 2

所以我们有以下属性：

优先事项定义明确且有限
需要线程安全
队列大小固定为2000条消息，其中排除此项以下的最低项目

编写支持所有这些属性的优先级队列非常容易：

public class BoundedPriorityQueue<T>
{
    private object locker;
    private int maxSize;
    private int count;
    private LinkedList<T>[] Buckets;

    public BoundedPriorityQueue(int buckets, int maxSize)
    {
        this.locker = new object();
        this.maxSize = maxSize;
        this.count = 0;
        this.Buckets = new LinkedList<T>[buckets];
        for (int i = 0; i < Buckets.Length; i++)
        {
            this.Buckets[i] = new LinkedList<T>();
        }
    }

    public bool TryUnsafeEnqueue(T item, int priority)
    {
        if (priority < 0 || priority >= Buckets.Length)
            throw new IndexOutOfRangeException("priority");

        Buckets[priority].AddLast(item);
        count++;

        if (count > maxSize)
        {
            UnsafeDiscardLowestItem();
            Debug.Assert(count <= maxSize, "Collection Count should be less than or equal to MaxSize");
        }

        return true; // always succeeds
    }

    public bool TryUnsafeDequeue(out T res)
    {
        LinkedList<T> bucket = Buckets.FirstOrDefault(x => x.Count > 0);
        if (bucket != null)
        {
            res = bucket.First.Value;
            bucket.RemoveFirst();
            count--;
            return true; // found item, succeeds
        }
        res = default(T);
        return false; // didn't find an item, fail
    }

    private void UnsafeDiscardLowestItem()
    {
        LinkedList<T> bucket = Buckets.Reverse().FirstOrDefault(x => x.Count > 0);
        if (bucket != null)
        {
            bucket.RemoveLast();
            count--;
        }
    }

    public bool TryEnqueue(T item, int priority)
    {
        lock (locker)
        {
            return TryUnsafeEnqueue(item, priority);
        }
    }

    public bool TryDequeue(out T res)
    {
        lock (locker)
        {
            return TryUnsafeDequeue(out res);
        }
    }

    public int Count
    {
        get { lock (locker) { return count; } }
    }

    public int MaxSize
    {
        get { return maxSize; }
    }

    public object SyncRoot
    {
        get { return locker; }
    }
}

在O（1）时间内支持Enqueue / Dequeue，TryEnqueue和TryDequeue方法保证是线程安全的，并且集合的大小永远不会超过您在构造函数中指定的最大大小。

TryEnqueue和TryDequeue上的锁非常精细，因此无论何时需要批量加载或卸载数据，都可能会受到影响。如果您需要预先加载包含大量数据的队列，请锁定SyncRoot并根据需要调用不安全的方法。

Answer 3

如果您有一定数量的优先级，我只需创建一个包含两个或更多私有队列的复合Queue类。

尽管您可以通过添加优先级枚举和开关来确定将项目排队的位置，但可以进行大幅简化的示例。

class PriorityQueue {

    private readonly Queue normalQueue = new Queue();
    private readonly Queue urgentQueue = new Queue();

    public object Dequeue() {
        if (urgentQueue.Count > 0) { return urgentQueue.Dequeue(); }
        if (normalQueue.Count > 0) { return normalQueue.Dequeue(); }
        return null;
    }

    public void Enqueue(object item, bool urgent) {
        if (urgent) { urgentQueue.Enqueue(item); }
        else { normalQueue.Enqueue(item); }
    }
}

Answer 4

我假设你可以有重复的优先事项。

.NET中没有容器允许重复键类似于C ++多图。您可以通过几种不同的方式执行此操作，或者使用具有每个优先级键的值数组的SortedList（并从该数组中获取第一项作为返回值）; SortedList是一个平衡的树（IIRC），应该为你提供良好的插入和检索性能。

Answer 5

这实际上取决于您可能会看到的队列长度的分布。 2000是最大值，但是平均值是什么，分布是什么样的？如果N通常很小，则简单的列表＆lt;＆gt;用蛮力搜索下一个最低可能是一个不错的选择。

您是否已将您的应用程序分析为知道这是一个瓶颈？

          "Never underestimate the power of a smart compiler 
           and a smart CPU with registers and on-chip memory 
           to run dumb algorithms really fast"

c＃中实现优先级排队队列的最快集合是什么？

5 个答案: