C# 数据结构之【队列】C#队列

1. 描述

队列：队列遵循先进先出（FIFO）原则，在一端进行插入操作，在另一端进行删除操作。

2. 应用示例

cs 复制代码

using System;

namespace DataStructure
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // 创建一个队列
            Queue<int> queue = new Queue<int>();

            // 向队列中添加元素
            queue.Enqueue(5);
            queue.Enqueue(10);
            queue.Enqueue(15);

            // 输出队列头部元素
            Console.WriteLine("队列头部元素：" + queue.Peek());

            // 从队列中取出元素并输出
            int dequeuedElement = queue.Dequeue();
            Console.WriteLine("取出的元素：" + dequeuedElement);

            // 再次输出队列头部元素
            Console.WriteLine("新的队列头部元素：" + queue.Peek());

        }

    }
}

3. 应用拓展

假设需要开发一个任务执行程序，在线等待接收任务，接到任务后开始执行，后面新收到的任务排队等待当前任务执行完再执行

首先新建一个任务执行类

cs 复制代码

namespace DataStructure
{
    public  class TaskClass
    {
        public TaskClass()
        {
          
            _tasks = new Queue<int>();
        }
        public static  Queue<int> _tasks;//任务队列
        public void StartProcessing()
        {
           
            Task.Run(async () =>
            {

                while (true)
                {
                    if (_tasks.Count!=0)
                    {
                        int productId = _tasks.Dequeue();
                        try
                        {
                            Console.WriteLine("执行任务中：" + productId);
                            await Task.Delay(3000);//模拟执行任务时间
                            Console.WriteLine("执行结束：" + productId);
                        }
                        catch (Exception ex)
                        {

                            // throw;
                        }
                        finally
                        {

                        }
                    }
                }
            });
        }
    }
}

调用该任务执行类，并添加任务

cs 复制代码

using System;

namespace DataStructure
{
    class Program
    {
        static async Task Main(string[] args)
        {
            TaskClass taskClass = new TaskClass();
            taskClass.StartProcessing();
            TaskClass._tasks.Enqueue(1);//新增任务
            TaskClass._tasks.Enqueue(2);//新增任务
            TaskClass._tasks.Enqueue(3);//新增任务
            Console.WriteLine("新增三条任务");
            Console.ReadKey();
        }

    }
}

运行结果显示，连续新增三条任务，执行时按照任务添加的序列依次执行

4. 应用拓展之 BlockingCollection

BlockingCollection<T>是一个在 C# 中用于线程安全的集合类，位于System.Collections.Concurrent命名空间。它主要用于在多线程环境下，方便地实现生产者 - 消费者模式。这个集合类提供了阻塞和非阻塞的方法来添加和获取元素。
其内部可以包装其他的集合类（如Queue<T>、Stack<T>等），默认情况下，如果没有指定内部集合类型，它会使用ConcurrentQueue<T>作为内部存储结构。

应用BlockingCollection新建任务执行类

cs 复制代码

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStructure
{
    public  class BlockingCollectionClass
    {

        public BlockingCollectionClass()
        {
          
            _tasks = new BlockingCollection<int >();
        }
        /// <summary>
        /// 任务接收队列
        /// </summary>
        public static  BlockingCollection<int > _tasks;

        /// <summary>
        /// 启动执行
        /// </summary>
        public void StartProcessing()
        {
          
            Task.Run(async () =>
            {
                foreach (var productId in _tasks.GetConsumingEnumerable())
                {
                    try
                    {
                        Console.WriteLine("BlockingCollection执行任务中：" + productId);
                        await Task.Delay(3000);//模拟执行任务时间
                        Console.WriteLine("BlockingCollection执行结束：" + productId);
                    }
                    catch (Exception ex)
                    {
                        // throw;
                    }
                    finally
                    {

                    }
                }
            });
        }
    }
}

调用执行

cs 复制代码

using System;

namespace DataStructure
{
    class Program
    {
        static async Task Main(string[] args)
        {
            BlockingCollectionClass taskClass = new BlockingCollectionClass();
            taskClass.StartProcessing();
            BlockingCollectionClass._tasks.Add(1);//新增任务
            BlockingCollectionClass._tasks.Add(2); ;//新增任务
            BlockingCollectionClass._tasks.Add(3); ;//新增任务
            Console.WriteLine("新增三条任务");
            Console.ReadKey();
        }

    }
}

运行结果

同样实现了任务按序执行的需求，但相对来说BlockingCollection是线程安全的，所以在这种需求模式下可以首选BlockingCollection