C#中的Task.Delay()和Thread.Sleep()

本文详细对比了Thread.Sleep()和Task.Delay()在多线程编程中的不同应用。Thread.Sleep()为同步延迟,会阻塞当前线程,不可取消;而Task.Delay()为异步延迟,不阻塞线程,可通过CancellationTokenSource取消。文章通过实例代码展示了两种方法的运行效果,并解释了在异步代码中使用Task.Delay()的优越性。
  1. Thread.Sleep()是同步延迟,Task.Delay()是异步延迟。
  2. Thread.Sleep()会阻塞线程,Task.Delay()不会。
  3. Thread.Sleep()不能取消,Task.Delay()可以。
  4. Task.Delay()实质创建一个运行给定时间的任务,Thread.Sleep()使当前线程休眠给定时间。
  5. 反编译Task.Delay(),基本上讲它就是个包裹在任务中的定时器。
  6. Task.Delay()和Thread.Sleep()最大的区别是Task.Delay()旨在异步运行,在同步代码中使用Task.Delay()是没有意义的;在异步代码中使用Thread.Sleep()是一个非常糟糕的主意。通常使用await关键字调用Task.Delay()。
  7. 我的理解:Task.Delay(),async/await和CancellationTokenSource组合起来使用可以实现可控制的异步延迟。

参考资料:

https://www.cnblogs.com/yy1234/p/8073732.html

https://blog.youkuaiyun.com/shu19880720/article/details/72901876

https://code.msdn.microsoft.com/ThreadSleep-vs-TaskDelay-766b46b7/view/Discussions#content

https://blog.youkuaiyun.com/wushang923/article/details/41015063

http://social.technet.microsoft.com/wiki/contents/articles/21177.visual-c-thread-sleep-vs-task-delay.aspx(评论区有争议)

https://oomake.com/question/5779232

https://walterlv.com/post/sleep-delay-zero-vs-yield.html

以下是本人调试时的代码:

代码1:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace Delay_And_Sleep
{
    class Program
    {
        static void Main(string[] args)
        {
            Task.Factory.StartNew(delegate
            {
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ****** 开始Sleep()");
                for (int i = 1; i < 20; i++)
                {
                    Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ***Sleep*** " + i);
                    Thread.Sleep(100);
                }
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ****** 结束Sleep()");
            });

            Task.Factory.StartNew(() =>
            {
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") +  " ====== 开始Delay()");
                for (int i = 101; i < 120; i++)
                {
                    Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ===Delay=== " + i);
                    Task.Delay(100);//需要.net4.5及以上
                }
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ====== 结束Delay()");
            });

            //Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "press enter to close . . .");
            Console.ReadLine();
        }
    }
}

运行结果:

代码2:

using System;
using System.Threading.Tasks;

namespace Delay_async_await
{
    class Program
    {
        //该段代码通过async/awatit实现“同步”Delay
        static void Main(string[] args)
        {
            Task.Factory.StartNew(async () =>
            {
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ====== 开始Delay()");
                for (int i = 101; i < 120; i++)
                {
                    Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ===Delay=== " + i);
                    await Task.Delay(100);//需要.net4.5及以上
                }
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ====== 结束Delay()");
            });

            //Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "press enter to close . . .");
            Console.ReadLine();
        }
    }
}

运行结果:

代码3:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 取消Delay
{
    public partial class Form1 : Form
    {
        CancellationTokenSource cts = new CancellationTokenSource();

        public Form1()
        {
            InitializeComponent();
        }

        void PutThreadSleep()
        {
            Thread.Sleep(5000);
        }

        async Task PutTaskDelay()
        {
            try
            {
                await Task.Delay(5000, cts.Token);//需要.net4.5的支持
            }
            catch (TaskCanceledException ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }

        private void btnThreadSleep_Click(object sender, EventArgs e)
        {
            PutThreadSleep();
            MessageBox.Show("Sleep : I am back");
        }

        //使用async/await便于观察效果;不用的话就直接弹出MessageBox了
        private async void btnTaskDelay_Click(object sender, EventArgs e)
        {
            await PutTaskDelay();
            MessageBox.Show("Delay : I am back");
        }

        private void btnCancelTaskDelay_Click(object sender, EventArgs e)
        {
            cts.Cancel();
        }
    }
}

运行结果:

 

`Task.Delay` 是 C# 中用于**非阻塞地延迟执行**的一个重要方法,常用于异步编程中替代 `Thread.Sleep`,特别是在需要等待一段时间后再继续执行逻辑的场景(如轮询、重试机制、动画控制等)。 它返回一个 `Task`,可以在 `async/await` 上下文中使用,不会阻塞主线程。 --- ### ✅ 基本语法 ```csharp await Task.Delay(millisecondsDelay); ``` #### 示例:简单延迟 2 秒 ```csharp using System; using System.Threading.Tasks; public class DelayExample { public async Task Run() { Console.WriteLine("开始..."); await Task.Delay(2000); // 等待 2 秒(非阻塞) Console.WriteLine("2秒后执行"); } public static async Task Main(string[] args) { var example = new DelayExample(); await example.Run(); } } ``` > 输出: ``` 开始... (等待 2 秒) 2秒后执行 ``` --- ### 🔧 参数说明 ```csharp Task.Delay(int millisecondsDelay) Task.Delay(TimeSpan delay) Task.Delay(int millisecondsDelay, CancellationToken cancellationToken) ``` | 参数 | 说明 | |------|------| | `millisecondsDelay` | 延迟毫秒数(如 1000 = 1秒) | | `TimeSpan` | 可传入 `TimeSpan.FromSeconds(5)` 更清晰 | | `CancellationToken` | 支持取消延迟操作 | --- ### ✅ 实际应用场景 #### 1. **轮询检查某个条件是否满足** ```csharp private async Task WaitForResourceLoaded() { while (!IsResourceLoaded()) { Console.WriteLine("正在检查资源状态..."); await Task.Delay(500); // 每 500ms 检查一次 } Console.WriteLine("资源已加载,继续执行!"); } ``` #### 2. **带超时的等待** ```csharp private async Task<bool> WaitForResourceWithTimeout(int timeoutMs = 10000) { var delayTask = Task.Delay(timeoutMs); var checkTask = Task.Run(async () => { while (!IsResourceLoaded()) { await Task.Delay(100); } }); // 谁先完成? var completed = await Task.WhenAny(checkTask, delayTask); if (completed == delayTask) { Console.WriteLine("❌ 等待超时!"); return false; } Console.WriteLine("✅ 资源加载成功!"); return true; } ``` #### 3. **支持取消的延迟(使用 CancellationToken)** ```csharp private async Task PollingWithCancellation(CancellationToken token) { try { while (!IsResourceLoaded()) { Console.WriteLine("轮询中..."); await Task.Delay(1000, token); // 可被取消 } Console.WriteLine("完成!"); } catch (OperationCanceledException) { Console.WriteLine("轮询被取消!"); } } // 使用示例 var cts = new CancellationTokenSource(); // cts.Cancel(); // 调用此行可提前终止轮询 await PollingWithCancellation(cts.Token); ``` --- ### ⚠️ 注意事项 | 问题 | 正确做法 | |------|----------| | ❌ `Task.Delay(0)` | ✅ 等价于让出当前时间片,类似“yield”,可用于避免阻塞UI线程 | | ❌ 在同步方法中调用 `.Result` 或 `.Wait()` | ✅ 会导致死锁(尤其在 UI 线程),应改为 `await` | | ❌ 使用 `Thread.Sleep(1000)` 替代 `Task.Delay` | ✅ `Sleep` 是阻塞式,会卡住线程;`Delay` 是异步非阻塞 | --- ### 🆚 Task.Delay vs Thread.Sleep | 对比项 | `Task.Delay` | `Thread.Sleep` | |--------|---------------|----------------| | 是否阻塞线程 | ❌ 否(异步等待) | ✅ 是(阻塞当前线程) | | 是否可取消 | ✅ 支持 `CancellationToken` | ❌ 不支持 | | 性能影响 | 小(仅注册定时器) | 大(浪费线程资源) | | 适用场景 | 异步上下文(ASP.NET、WPF、Unity、服务端) | 控制台测试或后台线程 | --- ### 💡 在 Unity 中使用 Task.Delay Unity 默认不启用 .NET 的完整异步支持,但你可以通过以下方式使用: 1. **设置脚本运行时为 .NET 4.x** 2. **安装 UniTask(推荐)**:[https://github.com/Cysharp/UniTask](https://github.com/Cysharp/UniTask) ```csharp // 使用 UniTask(性能更好,兼容 Unity 主线程) await UniTask.Delay(TimeSpan.FromSeconds(2)); Debug.Log("延迟完成"); ``` 否则原生 `Task.Delay` 在某些平台可能无法正确回调到主线程。 --- ### ✅ 总结 `Task.Delay` 是现代 C# 异步编程的核心工具之一,特别适合: - 非阻塞延时 - 轮询机制 - 超时控制 - 重试逻辑(配合 `Polly` 等库) > ✅ 推荐用法:`await Task.Delay(500);` > ❌ 避免用法:`Task.Delay(500).Wait();` ---
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值