摘要：
一、Queue表示对象的先进先出(FIFO)集合，非线程安全常用方法Dequeue入队Enqueue出队Contains队列中是否存在某元素Clear清空队列封装：//////QueuePool（先进先出）//////表示泛型，QueuePool中元素的类型publicclassQueuePool˂
一、Queue
表示对象的先进先出(FIFO)集合，非线程安全
| 常用方法 | |
| Dequeue | 入队 |
| Enqueue | 出队 |
| Contains | 队列中是否存在某元素 |
| Clear | 清空队列 |
封装：
/// <summary>
/// QueuePool（先进先出）
/// </summary>
/// <typeparam name="T">表示泛型，QueuePool中元素的类型</typeparam>
public class QueuePool<T>
{
private Queue<T> myPool = null;
/// <summary>
/// 按照设定的大小初始化 QueuePool
/// </summary>
/// <param name="capacity"> QueuePool 最大容量</param>
public QueuePool(int capacity)
{
myPool = new Queue<T>(capacity);
}
/// <summary>
/// 向 QueuePool 中添加对象
/// </summary>
/// <param name="item">待添加对象</param>
public void Enqueue(T item)
{
if (item == null)
throw new ArgumentNullException("Items added to a QueuePool cannot be null");
lock (myPool)
{
myPool.Enqueue(item);
}
}
/// <summary>
/// 向 QueuePool 中提取对象，并移除该对象
/// </summary>
/// <returns>提取出来的对象</returns>
public T Dequeue()
{
lock (myPool)
{
return myPool.Dequeue();
}
}
/// <summary>
/// 向 QueuePool 中提取对象，但不移除该对象
/// </summary>
/// <returns>提取出来的对象</returns>
public T Peek()
{
lock (myPool)
{
return myPool.Peek();
}
}
/// <summary>
/// 从 QueuePool 中移除所有的对象。
/// </summary>
public void Clear()
{
lock (myPool)
{
myPool.Clear();
}
}
/// <summary>
/// 判断某个对象是否在 QueuePool 中
/// </summary>
public bool Contains(T item)
{
lock (myPool)
{
return myPool.Contains(item);
}
}
/// <summary>
/// 获取 QueuePool 中包含的对象个数
/// </summary>
public int Count { get => myPool.Count(); }
}
二、Stack
表示对象的简单后进先出 (LIFO) 非泛型集合，非线程安全
| 常用方法 | |
| Push | 入栈 |
| Pop | 出栈 |
| Contains | 堆栈中是否存在某元素 |
| Clear | 清空堆栈 |
封装：
/// <summary>
/// StackPool（后进先出）
/// </summary>
/// <typeparam name="T">表示泛型，StackPool中元素的类型</typeparam>
public class StackPool<T>
{
private Stack<T> myPool = null;
/// <summary>
/// 按照设定的大小初始化 StackPool
/// </summary>
/// <param name="capacity"> StackPool 最大容量</param>
public StackPool(int capacity)
{
myPool = new Stack<T>(capacity);
}
/// <summary>
/// 向 StackPool 中添加对象
/// </summary>
/// <param name="item">待添加对象</param>
public void Push(T item)
{
if (item == null)
throw new ArgumentNullException("Items added to a StackPool cannot be null");
lock (myPool)
{
myPool.Push(item);
}
}
/// <summary>
/// 向 StackPool 中提取对象，并移除该对象
/// </summary>
/// <returns>提取出来的对象</returns>
public T Pop()
{
lock (myPool)
{
return myPool.Pop();
}
}
/// <summary>
/// 向 StackPool 中提取对象，但不移除该对象
/// </summary>
/// <returns>提取出来的对象</returns>
public T Peek()
{
lock (myPool)
{
return myPool.Peek();
}
}
/// <summary>
/// 从 StackPool 中移除所有的对象。
/// </summary>
public void Clear()
{
lock (myPool)
{
myPool.Clear();
}
}
/// <summary>
/// 判断某个对象是否在 StackPool 中
/// </summary>
public bool Contains(T item)
{
lock (myPool)
{
return myPool.Contains(item);
}
}
/// <summary>
/// 获取 StackPool 中包含的对象个数
/// </summary>
public int Count { get => myPool.Count(); }
}
三、ConcurrentQueue
表示线程安全的先进先出 (FIFO) 集合
常用方法 | |
Dequeue | 入队 |
TryDequeue(T) | 出队 |
四、ConCurrentStack
表示线程安全的后进先出 (LIFO) 集合
常用方法 | |
Push | 入栈 |
TryPop(T) | 出栈 |