C# Queue源码剖析

源代码版本为 .NET Framework 4.6.1

本系列持续更新，敬请关注

有投入，有产出。

（注：非基础性，主要涉及Queue的实现原理）

水平有限，若有不对之处，望指正。

Queue表示对象的先进先出集合。实现了ICollection接口，可以由数组或链表两种形式实现，在.NET中是以数组的形式实现的。

概念

队列是一种特殊的线性表，特殊之处在于它只允许在表头（head）进行删除操作，而在表尾（tail）进行插入操作。



队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素成为出队。因为队列只允许在一段插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表

队列可以分为顺序队列和循环队列，.NET中为了提高空间的利用率，采用的是循环队列。

循环队列

为充分利用向量空间，克服”假溢出”（由于入队和出队操作中，头尾指针只增加不减小，致使被删元素的空间永远无法重新利用）现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。概念图如下：



循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成空队列和满队列时头尾指针均相等。因此，无法通过条件front==rear来判别队列是”空”还是”满”，.NET使用一下方法判断空队列和满队列（实际.NET中，队列的长度时自动扩容的）：

（1）私有成员_size = 0时，为空队列。

（2）_size == _array.Length时（_array为Queue内部维护的实际数据数组），为满队列，这个时候会进行自动扩容（新建一个2倍于原容量的数组）。

进入主题，上代码解说

基本成员

private T[] _array;
private int _head;       // 表头
private int _tail;       // 表尾
private int _size;       // 队列元素数量
private int _version;
[NonSerialized]
private Object _syncRoot;

private const int _MinimumGrow = 4;        // 最小增长值
private const int _ShrinkThreshold = 32;   // 收缩阈值
private const int _GrowFactor = 200;       // 每次增长双倍
private const int _DefaultCapacity = 4;    // 默认容量
static T[]  _emptyArray = new T[0];        //空数组

_head：一个指向队列头元素的索引，因为是循环列队，_head值有可能大于_tail值。

_tail：一个指向队列尾元素的索引，因为是循环列队，_tail值有可能笑于_head值。

_size：记录队列中元素的总数量。

_MinimumGrow： 队列每一次的最小扩容量。

_ShrinkThreshold：“迷”之收缩阈值。

_GrowFactor：增长因子。

_DefaultCapacity： 默认初始容量。

_emptyArray：默认空数组。

初始化函数

public Queue() {
_array = _emptyArray;
}

public Queue(int capacity) {
if (capacity < 0)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNumRequired);

_array = new T[capacity];
_head = 0;
_tail = 0;
_size = 0;
}

public Queue(IEnumerable<T> collection){
if (collection == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);

_array = new T[_DefaultCapacity];
_size = 0;
_version = 0;

using(IEnumerator<T> en = collection.GetEnumerator()) {
while(en.MoveNext()) {
Enqueue(en.Current);
}
}
}

有三个初始化函数，一般初始化都会使用初始默认值_head和_tail最初都指向索引0（不代表_head=_tail就是空数组），_size=0长度为0。

入队

突然想起，军训期间被罚做完俯卧撑后，教官大喊入队。

入队的方法：Enqueue(T item)

public void Enqueue(T item) {
//动态扩容
if (_size == _array.Length) {
int newcapacity = (int)((long)_array.Length * (long)_GrowFactor / 100);
if (newcapacity < _array.Length + _MinimumGrow) {
newcapacity = _array.Length + _MinimumGrow;
}
SetCapacity(newcapacity);
}

_array[_tail] = item;
_tail = (_tail + 1) % _array.Length;
_size++;
_version++;
}

入队看起来很简单，通过_tail拿到队尾索引，将元素插入队尾即可。但是这里有一点小细节：

_tail = (_tail + 1) % _array.Length

下个元素的队尾索引 = （当前队尾索引 + 1） % 数据数组长度，这里的数据数组长度不等同与队列元素数量。此公式与抑制了队尾索引不会超过数据数组长度，从而避免了数据溢出的产生（同时也会导致队尾索引会小于队头索引，需要分情况进行处理）。

出队

出队有两种方法

（1）public T Peek()：返回位于 Queue 开始处的对象但不将其移除。

（2）public T Dequeue()：移除并返回位于 Queue 开始处的对象。

public T Peek() {
if (_size == 0)
ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EmptyQueue);

return _array[_head];
}

public T Dequeue() {
if (_size == 0)
ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EmptyQueue);

T removed = _array[_head];
_array[_head] = default(T);
_head = (_head + 1) % _array.Length;
_size--;
_version++;
return removed;
}

Peek()简单粗暴，通过索引直接返回数据。

Queue没有提供Remove方法，但是Dequeue具有删除功能并返回头元素。被移除的元素直接指向null（空引用）。并且头元素索引向前移动（这是一个跑圈圈的游戏，你懂的）。

查询

Contains(T item)判断队列中是否至少包含一个匹配的元素存在 是则返回true，否则返回false。

public bool Contains(T item) {
int index = _head;
int count = _size;

EqualityComparer<T> c = EqualityComparer<T>.Default;
while (count-- > 0) {
if (((Object) item) == null) {
if (((Object) _array[index]) == null)
return true;
}
else if (_array[index] != null && c.Equals(_array[index], item)) {
return true;
}
index = (index + 1) % _array.Length;
}

return false;
}

容量调整

容量调整，可以重置队列空间，如果元素数小于当前容量的 90%，将容量设置为 Queue中的实际元素数。

public void TrimExcess() {
int threshold = (int)(((double)_array.Length) * 0.9);
if( _size < threshold ) {
SetCapacity(_size);
}
}

private void SetCapacity(int capacity) {
//创建新数组
T[] newarray = new T[capacity];
if (_size > 0) {
if (_head < _tail) {
//头索引小于尾索引
Array.Copy(_array, _head, newarray, 0, _size);
} else {
//头索引大于尾索引
Array.Copy(_array, _head, newarray, 0, _array.Length - _head);
Array.Copy(_array, 0, newarray, _array.Length - _head, _tail);
}
}

_array = newarray;
_head = 0;
_tail = (_size == capacity) ? 0 : _size;
_version++;
}

最后

（1）Queue可以通过TrimExcess()方法，将容量下降到实际元素的数量.

（2）Queue允许重复的元素。

（3）Queue和Stack主要是用来存储临时信息的。（下篇文章写Stack，一种后进先出的集合）