C# Task任务队列

已于 2023-11-06 14:00:22 修改
阅读量1.4w 收藏 153
点赞数 60
分类专栏： C# 文章标签： c#
于 2021-05-28 14:34:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38693757/article/details/117361771
版权
本文介绍了如何使用C#的Task API解决需要按顺序延时执行任务的需求，避免UI界面卡死。通过逐步改进，从基本的Task用法到异步委托，再到封装任务队列，最终实现异步任务队列按顺序执行，确保任务顺序执行的同时，不会阻塞主线程。示例代码展示了具体的实现方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

一、需求

二、基本的Task用法

三、让Task任务按顺序执行

四、使用异步委托解决UI界面卡死问题

五、异步任务队列按顺序执行

六、封装任务队列

七、封装任务队列优化版

结束

一、需求

众所周知，方法体内代码是从上往下执行的，在我们工作中经常会遇到一些需要延时执行，但又必须按顺序来执行的需求。这要怎么解决呢。微软官方提供的Task API就是专门来解决这个问题的。那么下面就开始吧。

二、基本的Task用法

新建一个Winfrom项目

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 线程2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Task task1 = new Task(() =>
            {
                Thread.Sleep(400);
                Console.WriteLine("task1");
            });
            Task task2 = new Task(() =>
            {
                Thread.Sleep(300);
                Console.WriteLine("task2");
            });
            Task task3 = new Task(() =>
            {
                Thread.Sleep(200);
                Console.WriteLine("task3");
            });
            Task task4 = new Task(() =>
            {
                Thread.Sleep(100);
                Console.WriteLine("task4");
            });
            task1.Start();
            task2.Start();
            task3.Start();
            task4.Start();
        }
    }
}

运行:

由于各个任务内部延时不同，最先执行的Task1，反而最后一个执行完，如果既要做延时操作，又要求从任务按顺序执行，要怎么解决呢？

三、让Task任务按顺序执行

修改代码：

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 线程2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private List<Task> TaskList = new List<Task>();

        private void Form1_Load(object sender, EventArgs e)
        {
            Task task1 = new Task(() =>
            {
                Thread.Sleep(400);
                Console.WriteLine("task1");
            });
            Task task2 = new Task(() =>
            {
                Thread.Sleep(300);
                Console.WriteLine("task2");
            });
            Task task3 = new Task(() =>
            {
                Thread.Sleep(200);
                Console.WriteLine("task3");
            });
            Task task4 = new Task(() =>
            {
                Thread.Sleep(100);
                Console.WriteLine("task4");
            });

            TaskList.Add(task1);
            TaskList.Add(task2);
            TaskList.Add(task3);
            TaskList.Add(task4);

            foreach (Task task in TaskList)
            {
                task.Start();
                task.Wait();
            }
        }
    }
}

运行：

用上面的方法虽然有效，你可以看看，点击界面的时候，界面处鼠标指针会一直转圈，导致winfrom界面卡住，无法操作，这是因为使用Thread.Sleep 导致主线程阻塞，下面就来解决UI界面卡死的问题。

四、使用异步委托解决UI界面卡死问题

代码：

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 线程2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }


        private List<Task> TaskList = new List<Task>();


        private void Button_Calculate_Click(object sender, EventArgs e)
        {
            Task task1 = new Task(async () =>
            {
                await Task.Delay(TimeSpan.FromSeconds(4));
                Console.WriteLine("task1");
            });
            Task task2 = new Task(async () =>
            {
                await Task.Delay(TimeSpan.FromSeconds(3));
                Console.WriteLine("task2");
            });
            Task task3 = new Task(async () =>
            {
                await Task.Delay(TimeSpan.FromSeconds(2));
                Console.WriteLine("task3");
            });
            Task task4 = new Task(async () =>
            {
                await Task.Delay(TimeSpan.FromSeconds(1));
                Console.WriteLine("task4");
            });

            TaskList.Add(task1);
            TaskList.Add(task2);
            TaskList.Add(task3);
            TaskList.Add(task4);

            foreach (Task task in TaskList)
            {
                task.Start();
                task.Wait();
            }
        }
    }
}

运行：

用异步方式虽然界面不会卡住，但另一个问题来了，task.wait()方法似乎没有效果。里面的任务队列依然没有按顺序来执行。那么如何即使用异步执行，也不阻塞主线程，而且要任务按顺序来执行呢？

五、异步任务队列按顺序执行

代码：

private void Test()
{
    Task.Run(() =>
    {
        Task t1 = new Task(() => 
        {
            Thread.Sleep(2000);
            Console.WriteLine("t1");
        });
        t1.Start();
        t1.Wait();

        Task t2 = new Task(() => 
        {
            Thread.Sleep(1000);
            Console.WriteLine("t2");
        });
        t2.Start();
        t2.Wait();

        Console.WriteLine("线程执行完毕");
    });
}

运行：

效果是实现了，代码看起来好搓啊，强迫症都犯了，没关系，可以使用更优雅的写法：

private async void Test()
{
    await Task.Run(async () =>
    {
        await Task.Delay(4000);
        Trace.WriteLine("第1个线程执行");
    });
    await Task.Run(async () =>
    {
        await Task.Delay(3000);
        Trace.WriteLine("第2个线程执行");
    });
    await Task.Run(async () =>
    {
        await Task.Delay(2000);
        Trace.WriteLine("第3个线程执行");
    });
}

运行：

到此为止，功能就实现了，这个需求在Unity3d中使用协程很简单的几句就可以搞定，但在Winfrom等项目的开发中，确实有点繁琐。

六、封装任务队列

下面的代码我不认为是一个很好的写法，需要添加任务后，还得手动去调用，如果能添加到任务队列就不管了，让其自己自动按顺序来执行任务，岂不是更好，读者如果有兴趣自己去完善这个猜想。另外，在游戏开发中，比如RGP项目中，有专门的任务系统，它和我这个帖子的概念不能混为一谈，RPG任务系统更多的偏向数据的存取，来获取任务的完成状态。

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Utils
{
    public class TaskQueue
    {
        /// <summary>
        /// 任务列表
        /// </summary>
        private List<Task> TaskList = null;
        /// <summary>
        /// 是否在执行任务中
        /// </summary>
        private bool isPerformTask = false;
        /// <summary>
        /// 执行完任务的回调
        /// </summary>
        public Action CallBack = null;


        private static TaskQueue _instance = null;
        public static TaskQueue Instance
        {
            get
            {
                if (_instance == null)
                    _instance = new TaskQueue();
                return _instance;
            }
        }

        /// <summary>
        /// 添加任务
        /// </summary>
        /// <param name="task"></param>
        public void AddTask(Task task)
        {
            if (isPerformTask)
            {
                Console.WriteLine("[TaskQueue]任务正在执行中，此时不能做赋值操作");
                return;
            }

            if (task != null)
            {
                TaskList.Add(task);
            }
        }

        /// <summary>
        /// 执行任务
        /// </summary>
        public void PerformTask()
        {
            if (isPerformTask)
            {
                Console.WriteLine("[TaskQueue]任务正在执行中，不可重复调用");
                return;
            }
            if (TaskList == null || TaskList.Count == 0)
            {
                Console.WriteLine("[TaskQueue]任务列表为空");
                return;
            }         

            Task.Run(() =>
            {
                isPerformTask = true;

                foreach (Task item in TaskList)
                {
                    item.Start();
                    item.Wait();
                }

                TaskList.Clear();
                isPerformTask = false;

                if (CallBack != null) CallBack();
            });
        }

        private TaskQueue()
        {
            TaskList = new List<Task>();
        }
    }
}

调用：

Task task1 = new Task(() =>
{
    Thread.Sleep(1000);
    Console.WriteLine("t1");
});
Task task2 = new Task(() =>
{
    Thread.Sleep(2000);
    Console.WriteLine("t2");
});
Task task3 = new Task(() =>
{
    Console.WriteLine("t3");
});
Action callback = () =>
{
    Console.WriteLine("所有任务执行完成");
};
TaskQueue.Instance.AddTask(task1);
TaskQueue.Instance.AddTask(task2);
TaskQueue.Instance.AddTask(task3);
TaskQueue.Instance.CallBack = callback;
TaskQueue.Instance.PerformTask();

运行：

七、封装任务队列优化版

2022.07.26 优化，和上面版本的区别是，任务添加完成后，会自动调用。

执行任务队列，任务会一个个执行，中间可等待，并且不会阻塞主线程，在运行的时候，可以向任务队列中添加任务，不会影响任务的执行，

代码：

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

internal class TaskQueue
{
    /// <summary>
    /// 任务队列
    /// </summary>
    private static Queue<TaskData> QueuesTask = new Queue<TaskData>();
    /// <summary>
    /// 任务队列是否在执行中
    /// </summary>
    private static bool isExecuteing = false;

    /// <summary>
    /// 任务是否进行中
    /// </summary>
    /// <returns></returns>
    public static bool IsTasking { get => isExecuteing; }

    /// <summary>
    /// 添加任务，任务会按照队列自动执行
    /// </summary>
    /// <param name="task"></param>
    public static void AddTaskAndRuning(TaskData taskData)
    {
        if (taskData == null) return;

        QueuesTask.Enqueue(taskData);

        StartPerformTask();
    }

    /// <summary>
    /// 执行任务
    /// </summary>
    private static async void StartPerformTask()
    {
        if (isExecuteing) return; 

        while (QueuesTask.Count > 0)
        {
            isExecuteing = true;
            await Task.Run(() =>
            {
                var taskDatas = QueuesTask.Dequeue();
                var task = taskDatas.Tasks;
                task.Start();
                task.Wait();

                if (taskDatas.CallBack != null) 
                    taskDatas.CallBack(taskDatas.Other);
            });
        }

        isExecuteing = false;
    }

    private TaskQueue() { }
}

public class TaskData
{
    /// <summary>
    /// 任务名
    /// </summary>
    public string Name { get; set; }
    /// <summary>
    /// 其他内容
    /// </summary>
    public string Other { get; set; }
    /// <summary>
    /// 任务
    /// </summary>
    public Task Tasks { get; set; }
    /// <summary>
    /// 任务完成后的回调
    /// </summary>
    public Action<string> CallBack { get; set; }
}

调用：

TaskData taskData2 = new TaskData();
taskData2.Other = "来了老弟";
taskData2.Tasks = new Task(() =>
{
    Thread.Sleep(4000);
    Console.WriteLine("[Form1]taskData2");
});
taskData2.CallBack = (string res) =>
{
    Console.WriteLine("[Form1]taskData2执行完的回调，返回的参数是：{0}", res);
};
TaskQueue.AddTaskAndRuning(taskData2);


TaskData taskData3 = new TaskData();
taskData3.Other = "老六";
taskData3.Tasks = new Task(() =>
{
    Thread.Sleep(5000);
    Console.WriteLine("[Form1]taskData3");
});
taskData3.CallBack = (string res) =>
{
    Console.WriteLine("[Form1]taskData3执行完的回调，返回的参数是：{0}", res);
};
TaskQueue.AddTaskAndRuning(taskData3);

运行：

结束

如果这个帖子对你有用，欢迎给我点赞 + 留言，谢谢

end

深入探索C#分布式任务队列的设计与实现——打造高效异步处理系统
墨夶的博客
03-28 432
分布式任务队列是一种用于管理任务执行顺序的技术，它允许任务被提交到队列中并在不同的机器上并发执行。这种架构不仅提高了系统的可扩展性，还增强了其容错能力。任务定义：明确任务的输入输出以及执行逻辑。任务调度：决定任务何时何地被执行。状态跟踪：记录任务的状态变化以便于监控和故障恢复。负载均衡：确保任务均匀分布在可用的工作节点上。通过上述步骤，我们已经构建了一个基本的分布式任务队列系统。虽然这里的实现相对简单，但它展示了构建此类系统的基本思路和技术要点。
C#并行任务库（TPL）中Task详解
weixin_41245990的博客
06-01 1120
Task出现之前，微软的多线程处理方式有：Thread→ThreadPool→委托的异步调用，虽然也可以满足基本业务需要的多线程场景，但它们在多个线程的等待处理方面、资源占用方面、线程延续和阻塞方面、线程的取消方面等都显得比较笨拙，在面对复杂的业务场景下，显得有点捉襟见肘了。ThreadPool相比Thread来说具备了很多优势，但是ThreadPool却又存在一些使用上的不方便。ThreadPool不支持线程的取消、完成、失败通知等交互性操作；ThreadPool不支持线程执行的先后次序；
C#任务队列的实现
10-30
用C#实现任务队列，一个队列存放任务，线程互斥的从任务队列中取，放任务，任务队列为空，线程等待，直到有任务加入队列为止。
C#实现任务队列
Tonny_007的IT家园
06-17 9748
using System; using System.Collections.Generic; using System.Linq; using System.Threading; using System.Text; namespace TaskList { public class Tasks { private static Queue m_List;
【C#语言】详解C#中的Task与Thread
最新发布
成为你自己，做你想做的
03-21 1711
在现代软件开发中，并发编程是提升应用性能的关键技术。Thread和Task。本文将深入探讨它们的特性、区别，并通过实际案例展示最佳使用场景。在大多数现代C#应用中，Task因其高效性和易用性成为首选方案。但理解Thread的底层机制对处理特殊场景仍有重要意义。开发者应根据具体需求选择最合适的并发工具，在性能和开发效率之间找到最佳平衡点。标题详情作者JosieBook头衔CSDN博客专家资格、阿里云社区专家博主、软件设计工程师博客内容。
任务队列(Unity,C#)
明明明的博客
06-22 1697
任务队列
tasklist c#
03-26
tasklist c#
C# 数据结构之【队列】C#队列
weixin_46540714的博客
11-21 1192
C#中的队列以及队列的应用，生产者-消费者模式的讲解
C#队列
zhu58252601的博客
11-19 2648
队列说明 什么是队列？我想学习过数据结构应该很清楚，如果没有仔细了解，只要记住队列是一个先进先出的列表即可，列表中可以是线程，可以是预备执行的函数的入口，可以是地址，可以是数据，在C#中，Queue 类可以实现队列，这一个类可以简单的让我们完成数据的插入和获取，可以在便利性这一块十分出众的。 目标 在这一步，我们将建立一个存储String数据的队列，为了实用，队列能够用多线程的方式来插入，后台将有...
C#利用Task实现任务超时多任务一起执行的方法
08-28
C#利用Task实现任务超时多任务一起执行的方法 本文主要介绍了C#利用Task实现任务超时，多任务一起执行的相关知识点。Task是C#中的一个异步编程模型，能够帮助开发者更方便地编写异步代码。下面是本文中所涉及的知识...
C#任务处理队列
郭旭日(Net)
08-02 499
C#的线程安全处理队列。但是还是有性能问题。
C# Queue队列
C/C#、Android driver、STM32、Linux等等。
08-05 5396
目录 前言 一、队列的新建 二、入队 三、出队 四、清除队列 前言 我们在处理数据接收或发送的时，为避免数据量较多出现顺序混乱或是多线程共享内存造成数据覆盖问题， 经常需要对数据处理做到先进先出（FIFO）。于是我们经常要队列（Queue），顾名思义也就是和平时排队一样，一个一个的处理，遵循先来后到，不插队，不优先。 在C#中，队列封装的很好，使用起来也很方便。它属于系统类的集合（Collection）类中...
C# 批量任务队列
蓝创精英团队
12-23 1767
在实际项目中，需要批量处理一定数量的队列数据，而不是，一个一个处理，来提高效率。 但是，默认是不支持的。这个时候，就需要这样的一个业务逻辑对象。 /// <summary> /// 任务队列接口 /// </summary> public interface ITaskQueue<T> { /// &...
C#队列（Queue）
我想我是海 冬天的大海 心情随风轻摆
06-03 948
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Collections; namespace QueueTest { class Program { static void Main(string[] args)
C# 队列(Queue)
热门推荐
熊思雨的博客
05-26 1万+
表示对象的先进先出集合。队列和其他的数据结构一样，是一种存储容器，它遵循的原则，能够存储任意类型，但并不能获取到指定的位置，只能存入和取出，取出元素后，Queue 内部的元素自动删除，其实 队列 和 栈 使用方法和特点大致差不多，只是取出数据的顺序会有些不一样。
C# 队列（Queue）
ilipan的专栏
05-06 894
队列（Queue）代表了一个先进先出的对象集合。 using System; using System.Collections; namespace CollectionsApplication { class Program { static void Main(string[] args) { Queue q =
C# Task多线程与队列
chinaherolts2008的博客
12-15 1045
public static void RunTask(List list, Action action, int threadCount = 5, bool waitFlag = true) { ConcurrentQueue queue = new ConcurrentQueue(list); Task[] tasks = new Task[threadCount]; for (int i = 0; i < threadCount; i++) { tasks[i] = Task.Run(() =&g
C#实现队列
qq_42696107的博客
08-21 1297
C#实现队列
C#队列怎么输出任务
09-29
在C#中，如果你想要在队列里存储任务并逐个输出它们，可以使用`System.Collections.Generic.Queue<T>`这个类。首先，你需要创建一个队列，比如： ```csharp Queue<Task> taskQueue = new Queue<Task>(); ``` 然后，你可以将任务添加到队列中，例如： ```csharp Task task1 = Task.Run(() => Console.WriteLine("Task 1")); taskQueue.Enqueue(task1); ``` 当你想按照顺序处理这些任务时，可以使用一个循环结构，如`foreach`循环，从队列头部取出并执行任务： ```csharp foreach (Task task in taskQueue) { // 等待任务完成（如果有异步操作） await task; // 输出任务结果 Console.WriteLine($"Task completed: {task.Status}"); } ``` 这里我们假设`Task`是一个异步操作，所以在处理前需要等待它完成。如果任务不是异步的，那么可以直接运行而无需`await`。
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

熊思宇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值