C#多线程(11):线程等待
[TOC] 前面我们学习了很多用于线程管理的 类型,也学习了多种线程同步的使用方法,这一篇主要讲述线程等待相关的内容。
在笔者认真探究多线程前,只会
new Thread;锁?
Lock;线程等待?
Thread.Sleep()。
前面已经探究了创建线程的创建姿势和各种锁的使用,也学习了很多类型,也使用到了很多种等待方法,例如
Thread.Sleep()、
Thread.SpinWait();、
{某种锁}.WaitOne()等。
这些等待会影响代码的算法逻辑和程序的性能,也有可能会造成死锁,在本篇我们将会慢慢探究线程中等待。
前言
volatile 关键字
volatile关键字指示一个字段可以由多个同时执行的线程修改。
我们继续使用《C#多线程(3):原子操作》中的示例:
static void Main(string[] args) { for (int i = 0; i < 5; i++) { new Thread(AddOne).Start(); } Thread.Sleep(TimeSpan.FromSeconds(5)); Console.WriteLine("sum = " + sum); Console.ReadKey(); } private static int sum = 0; public static void AddOne() { for (int i = 0; i < 100_0000; i++) { sum += 1; } }
运行后你会发现,结果不为 500_0000,而使用
Interlocked.Increment(ref sum);后,可以获得准确可靠的结果。
你试试再运行下面的示例:
static void Main(string[] args) { for (int i = 0; i < 5; i++) { new Thread(AddOne).Start(); } Thread.Sleep(TimeSpan.FromSeconds(5)); Console.WriteLine("sum = " + sum); Console.ReadKey(); } private static volatile int sum = 0; public static void AddOne() { for (int i = 0; i < 100_0000; i++) { sum += 1; } }
你以为正常了?哈哈哈,并没有。
volatile 的作用在于读,保证了观察的顺序和写入的顺序一致,每次读取的都是最新的一个值;不会干扰写操作。
详情请点击:https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/volatile
其原理解释:https://theburningmonk.com/2010/03/threading-understanding-the-volatile-modifier-in-csharp/
三种常用等待
这三种等待分别是:
Thread.Sleep();
Thread.SpinWait();
Task.Delay();
Thread.Sleep();会阻塞线程,使得线程交出时间片,然后处于休眠状态,直至被重新唤醒;适合用于长时间的等待;
Thread.SpinWait();使用了自旋等待,等待过程中会进行一些的运算,线程不会休眠,用于微小的时间等待;长时间等待会影响性能;
Task.Delay();用于异步中的等待,异步的文章后面才写,这里先不理会;
这里我们还需要继续 SpinWait 和 SpinLock 这两个类型,最后再进行总结对照。
再说自旋和阻塞
前面我们学习过自旋和阻塞的区别,这里再来撸清楚一下。
线程等待有内核模式(Kernel Mode)和用户模式(User Model)。
因为只有操作系统才能控制线程的生命周期,因此使用
Thread.Sleep()等方式阻塞线程,发生上下文切换,此种等待称为内核模式。
用户模式使线程等待,并不需要线程切换上下文,而是让线程通过执行一些无意义的运算,实现等待。也称为自旋。
SpinWait 结构
微软文档定义:为基于自旋的等待提供支持。
SpinWait 是结构体;Thread.SpinWait() 的原理就是 SpinWait 。
如果你想了解 Thread.SpinWait() 是怎么实现的,可以参考 https://www.tabsoverspaces.com/233735-how-is-thread-spinwait-actually-implemented
线程阻塞是会耗费上下文切换的,对于过短的线程等待,这种切换的代价会比较昂贵的。在我们前面的示例中,大量使用了
Thread.Sleep()和各种类型的等待方法,这其实是不合理的。
SpinWait 则提供了更好的选择。
属性和方法
老规矩,先来看一下 SpinWait 常用的属性和方法。
属性:
属性 | 说明 |
---|---|
Count | 获取已对此实例调用 SpinOnce() 的次数。 |
NextSpinWillYield | 获取对 SpinOnce() 的下一次调用是否将产生处理器,同时触发强制上下文切换。 |
方法:
方法 | 说明 |
---|---|
Reset() | 重置自旋计数器。 |
SpinOnce() | 执行单一自旋。 |
SpinOnce(Int32) | 执行单一自旋,并在达到最小旋转计数后调用 Sleep(Int32) 。 |
SpinUntil(Func) | 在指定条件得到满足之前自旋。 |
SpinUntil(Func, Int32) | 在指定条件得到满足或指定超时过期之前自旋。 |
SpinUntil(Func, TimeSpan) | 在指定条件得到满足或指定超时过期之前自旋。 |
自旋示例
下面来实现一个让当前线程等待其它线程完成任务的功能。
其功能是开辟一个线程对 sum 进行
+1,当新的线程完成运算后,主线程才能继续运行。
class Program { static void Main(string[] args) { new Thread(DoWork).Start(); // 等待上面的线程完成工作 MySleep(); Console.WriteLine("sum = " + sum); Console.ReadKey(); } private static int sum = 0; private static void DoWork() { for (int i = 0; i < 1000_0000; i++) { sum++; } isCompleted = true; } // 自定义等待等待 private static bool isCompleted = false; private static void MySleep() { int i = 0; while (!isCompleted) { i++; } } }
新的实现
我们改进上面的示例,修改 MySleep 方法,改成:
private static bool isCompleted = false; private static void MySleep() { SpinWait wait = new SpinWait(); while (!isCompleted) { wait.SpinOnce(); } }
或者改成
private static bool isCompleted = false; private static void MySleep() { SpinWait.SpinUntil(() => isCompleted); }
SpinLock 结构
微软文档:提供一个相互排斥锁基元,在该基元中,尝试获取锁的线程将在重复检查的循环中等待,直至该锁变为可用为止。
SpinLock 称为自旋锁,适合用在频繁争用而且等待时间较短的场景。主要特征是避免了阻塞,不出现昂贵的上下文切换。
笔者水平有限,关于 SpinLock ,可以参考 https://www.c-sharpcorner.com/UploadFile/1d42da/spinlock-class-in-threading-C-Sharp/
另外,还记得 Monitor 嘛?SpinLock 跟 Monitor 比较像噢~https://www.cnblogs.com/whuanle/p/12722853.html#2monitor
在《C#多线程(10:读写锁)》中,我们介绍了 ReaderWriterLock 和 ReaderWriterLockSlim ,而 ReaderWriterLockSlim 内部依赖于 SpinLock,并且比 ReaderWriterLock 快了三倍。
属性和方法
SpinLock 常用属性和方法如下:
属性:
属性 | 说明 |
---|---|
IsHeld | 获取锁当前是否已由任何线程占用。 |
IsHeldByCurrentThread | 获取锁是否已由当前线程占用。 |
IsThreadOwnerTrackingEnabled | 获取是否已为此实例启用了线程所有权跟踪。 |
方法:
方法 | 说明 |
---|---|
Enter(Boolean) | 采用可靠的方式获取锁,这样,即使在方法调用中发生异常的情况下,都能采用可靠的方式检查 lockTaken以确定是否已获取锁。 |
Exit() | 释放锁。 |
Exit(Boolean) | 释放锁。 |
TryEnter(Boolean) | 尝试采用可靠的方式获取锁,这样,即使在方法调用中发生异常的情况下,都能采用可靠的方式检查 lockTaken以确定是否已获取锁。 |
TryEnter(Int32, Boolean) | 尝试采用可靠的方式获取锁,这样,即使在方法调用中发生异常的情况下,都能采用可靠的方式检查 lockTaken以确定是否已获取锁。 |
TryEnter(TimeSpan, Boolean) | 尝试采用可靠的方式获取锁,这样,即使在方法调用中发生异常的情况下,都能采用可靠的方式检查 lockTaken以确定是否已获取锁。 |
示例
SpinLock 的模板如下:
private static void DoWork() { SpinLock spinLock = new SpinLock(); bool isGetLock = false; // 是否已获得了锁 try { spinLock.Enter(ref isGetLock); // 运算 } finally { if (isGetLock) spinLock.Exit(); } }
这里就不写场景示例了。
需要注意的是, SpinLock 实例不能共享,也不能重复使用。
等待性能对比
大佬的文章,.NET 中的多种锁性能测试数据:http://kejser.org/synchronisation-in-net-part-3-spinlocks-and-interlocks/
这里我们简单测试一下阻塞和自旋的性能测试对比。
我们经常说,
Thread.Sleep()会发生上下文切换,出现比较大的性能损失。具体有多大呢?我们来测试一下。(以下运算都是在 Debug 下测试)
测试
Thread.Sleep(1):
private static void DoWork() { Stopwatch watch = new Stopwatch(); watch.Start(); for (int i = 0; i < 1_0000; i++) { Thread.Sleep(1); } watch.Stop(); Console.WriteLine(watch.ElapsedMilliseconds); }
笔者机器测试,结果大约 20018。
Thread.Sleep(1)减去等待的时间 10000 毫秒,那么进行 10000 次上下文切换需要花费 10000 毫秒,约每次 1 毫秒。
上面示例改成:
for (int i = 0; i < 1_0000; i++) { Thread.Sleep(2); }
运算,发现结果为 30013,也说明了上下文切换,大约需要一毫秒。
改成
Thread.SpinWait(1000):
for (int i = 0; i < 100_0000; i++) { Thread.SpinWait(1000); }
结果为 28876,说明自旋 1000 次,大约需要 0.03 毫秒。
- C# 多线程join的用法,等待多个子线程结束后再执行主线程
- C# 多线程的等待所有线程结束 用 ManualResetEvent 控制
- 【多线程】线程通信之等待/通知机制
- 性能优化-多线程-主线程等待子线程完成场景
- 多线程:C#线程同步lock,Monitor,Mutex,同步事件和等待句柄(中) (转)
- Linux下多线程编程__线程的创建pthread_create与退出pthread_exit,等待当前线程退出pthread_join,获取线程ID pthread_self
- C#多线程学习之如何操纵一个线程
- C# 进程、线程和多线程
- java基本教程之java线程等待与java唤醒线程 java多线程教程
- C#笔记19:多线程之线程启动、参数、返回值
- Java:多线程等待所有线程结束(CountDownLatch/CyclicBarrier)
- .NET组件程序设计 第8章 多线程和并发管理 同步线程_可等待事件
- C#笔记22:多线程之停止或取消线程
- .Net最简单的创建多线程主线程等待所有线程执行完成的例子
- C# 线程手册 第五章 多线程应用程序 .NET 中的扩展性
- .NET多线程编程(11)——c#线程基础的原子操作
- C# - 多线程 之 进程与线程
- [叩响C#之门]写给初学者:多线程系列(一)——线程的概念
- C# 多线程开发 1:使用 Thread 类创建与启动线程
- Java多线程系列--“基础篇”05之 线程等待与唤醒 (r)