读 dotnet 源代码 为何 Thread.Sleep 半毫秒和一毫秒等待时间差距如此之大

輝訊

本文记录我读 dotnet 的源代码了解到为什么调用 Thread.Sleep 的时候，传入的是不足一毫秒，如半毫秒时或 0.99 毫秒，与传入是一毫秒时，两者的等待时间差距非常大
大概如下的代码，分别进行两次传入给 Thread.Sleep 不同等待时间的循环测试。其中一次传入的是 0.99 毫秒，一次传入的是 1 毫秒

1. using System.Diagnostics;
3. var stopwatch = Stopwatch.StartNew();
5. for (int i = 0; i < 1000; i++)
6. {
7.     Thread.Sleep(TimeSpan.FromMilliseconds(0.99));
8. }
10. stopwatch.Stop();
12. Console.WriteLine($"耗时：{stopwatch.ElapsedMilliseconds}ms");
14. stopwatch.Restart();
15. for (int i = 0; i < 1000; i++)
16. {
17.     Thread.Sleep(TimeSpan.FromMilliseconds(1));
18. }
19. Console.WriteLine($"耗时：{stopwatch.ElapsedMilliseconds}ms");

复制代码

在我的设备上运行的输出内容如下

1. 耗时：0ms
2. 耗时：15665ms

复制代码

通过如上代码可以看到传入 0.99 毫秒时，居然接近统计不出来其耗时
而传入 1 毫秒时，由于在 Windows 下的最低 Thread.Sleep 时间大概在 15-16毫秒 左右，于是差不多是 15 秒左右的时间，这是符合预期的。即写入 Thread.Sleep(TimeSpan.FromMilliseconds(1)); 也可能差不多等待 15 毫秒的量程时间
那为什么 0.99 毫秒和 1 毫秒只差大概 0.1 毫秒的时间，却在等待过程中有如此长的时间差距
通过阅读 dotnet 的源代码，可以看到 Thread.Sleep 的实现代码大概如下

1. namespace System.Threading
2. {
3.     public sealed partial class Thread
4.     {
5.         ... // 忽略其他代码
6.         public static void Sleep(TimeSpan timeout) => Sleep(WaitHandle.ToTimeoutMilliseconds(timeout));
7.     }
8. }
10. namespace System.Threading
11. {
12.     public abstract partial class WaitHandle : MarshalByRefObject, IDisposable
13.     {
14.         internal static int ToTimeoutMilliseconds(TimeSpan timeout)
15.         {
16.             long timeoutMilliseconds = (long)timeout.TotalMilliseconds;
17.              ... // 忽略其他代码
18.             return (int)timeoutMilliseconds;
19.         }
20.         ... // 忽略其他代码
21.     }
22. }

复制代码

通过以上可以可见，这是直接将 TotalMilliseconds 强行转换为 int 类型，换句话说就是不到 1 毫秒的，都会被转换为 0 毫秒的值
于是即使是 0.99 毫秒，在这里的转换之下，依然会返回 0 毫秒回去
而 Thread.Sleep 底层里面专门为传入 0 毫秒做了特殊处理，将会进入自旋逻辑。大家都知道，进入自旋时，自旋的速度是非常快的
以上的 Thread.Sleep(TimeSpan.FromMilliseconds(0.99)); 代码和 Thread.Sleep(0) 在执行上等价的，意味着第一次只执行了一千次自旋，自然就几乎测试不出来耗时了
在 Windows 下的 Thread.Sleep 底层代码是写在 Thread.Windows.cs 代码里的，实现如下

1. namespace System.Threading
2. {
3.     public sealed partial class Thread
4.     {
5.         internal static void UninterruptibleSleep0() => Interop.Kernel32.Sleep(0);
7. #if !CORECLR
8.         private static void SleepInternal(int millisecondsTimeout)
9.         {
10.             Debug.Assert(millisecondsTimeout >= -1);
11.             Interop.Kernel32.Sleep((uint)millisecondsTimeout);
12.         }
13. #endif
15.         ... // 忽略其他代码
16.     }
17. }

复制代码

如上面代码，底层为 Kernel32 的 Sleep 函数，如官方文档所述，传入 0 是特殊的实现逻辑

If you specify 0 milliseconds, the thread will relinquish the remainder of its time slice but remain ready.

因此如果在 Thread.Sleep 方法里面传入的 TimeSpan 不足一毫秒，那就和传入 0 毫秒是相同的执行逻辑
更多基础技术博客，请参阅 博客导航

来源:https://www.cnblogs.com/lindexi/p/18381792
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！