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

一、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)	出栈