C#的队列(Queue，ConcurrentQueue)和堆栈(Stack，ConcurrentStack)

一、Queue

表示对象的先进先出(FIFO)集合，非线程安全

常用方法
Dequeue	入队
Enqueue	出队
Contains	队列中是否存在某元素
Clear	清空队列

 

封装：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

/// <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	清空堆栈

封装：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

/// <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)	出栈