zoukankan      html  css  js  c++  java
  • 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)

    出栈

  • 相关阅读:
    依次逐个亮灯并且每次只能亮一个灯的跑马灯程序
    逐个点亮LED灯,再逐个熄灭LED灯的跑马灯程序---基于74HC595移位锁存器,程序框架用switch语句
    把74HC595驱动程序翻译成类似单片机IO口直接驱动的方式
    两片联级74HC595驱动16个LED灯的基本驱动程序
    树莓派
    Linux I2C驱动
    转:使用 /proc 文件系统来访问 Linux 内核的内容
    转: 使用 /sys 文件系统访问 Linux 内核
    树梅派 -- 通过/sys读写ADC芯片 pcf8591
    树莓派 -- oled 续(2) python
  • 原文地址:https://www.cnblogs.com/yaosj/p/11138020.html
Copyright © 2011-2022 走看看