C# 异步编程基础(完结)_哔哩哔哩_bilibili
一、什么是线程Thread?
- 线程是一个可执行路径,它可以独立于其他线程执行。
- 每个线程都在操作系统的进程(Process)内执行,而操作系统进程提供了程序运行的独立环境。
- 单线程应用,在进程的独立环境里只跑一个线程,所以该线程拥有独占权。
- 多线程应用。单个进程中会跑多个线程,它们会共享当前的执行环境(尤其是内存)
- 例如,一个线程在后台读取数据,另一个线程在数据到达后进行展示
- 这个数据就被称作是共享的状态
例子
- 在单核计算机上,操作系统必须为每个线程分配“时间片”(在Windows中通常未20毫秒)来模拟并发,从而导致x和y块。
- 在多核或多处理器计算机上,这两个线程可以真正地并行执行(可能受到计算机上其他活动进程的竞争)
- 在本例中,由于控制台处理并发请求的机制的微妙性,您任然会得到重复的x和y块
术语:线程被抢占
- 线程在这个时候就可以称为被抢占了:
- 它的执行与另一个线程上执行的代码交织的那一点。
- 它的执行与另一个线程上执行的代码交织的那一点。
线程的一些属性
- 线程一旦开始执行,IsAlive就是True,线程结束就变成False。
- 线程结束的条件就是:线程构造函数传入的委托结束了执行。
- 线程一旦结束,就无法再重启。
- 每个线程都有Name属性,通常用于调试。
- 线程Name只能设置一次,以后更改会抛出异常。
- 静态的Thread.CurrentThread属性,会返回当前执行的线程
- 例子:CurrentThread
- 线程Name只能设置一次,以后更改会抛出异常。
- 例子:CurrentThread
输出结果:
输出结果不一样,CPU分配的“时间片”有关
二、Thread.Join()&Thread.Sleep()
Thread.Join
- 调用Join方法,就可以等待另一个线程结束
- 例子(join)
// See https://aka.ms/new-console-template for more information
using System;
namespace join和Sleep // Note: actual namespace depends on the project name.
{
internal class Program
{
#region Join
static Thread thread1, thread2;
static void Main(string[] args)
{
thread1 = new Thread(ThreadProc);
thread1.Name = "Thread1";
thread1.Start();
thread2 = new Thread(ThreadProc);
thread2.Name = "Thread2";
thread2.Start();
}
private static void ThreadProc()
{
Console.WriteLine("nCurrent thread{0}", Thread.CurrentThread.Name);
if (Thread.CurrentThread.Name == "Thread1" &&
thread2.ThreadState != ThreadState.Unstarted)
thread2.Join();
Thread.Sleep(1000);
Console.WriteLine("nCurrent thread{0}", Thread.CurrentThread.Name);
Console.WriteLine("Thread1: {0}", thread1.ThreadState);
Console.WriteLine("Thread2: {0}", thread2.ThreadState);
}
#endregion
}
}
- 调用Join方法,就可以等待另一个线程结束
- 例子(join)
// See https://aka.ms/new-console-template for more information
using System;
namespace join和Sleep // Note: actual namespace depends on the project name.
{
internal class Program
{
#region Join
static Thread thread1, thread2;
static void Main(string[] args)
{
thread1 = new Thread(ThreadProc);
thread1.Name = "Thread1";
thread1.Start();
thread2 = new Thread(ThreadProc);
thread2.Name = "Thread2";
thread2.Start();
}
private static void ThreadProc()
{
Console.WriteLine("nCurrent thread{0}", Thread.CurrentThread.Name);
if (Thread.CurrentThread.Name == "Thread1" &&
thread2.ThreadState != ThreadState.Unstarted)
thread2.Join();
Thread.Sleep(1000);
Console.WriteLine("nCurrent thread{0}", Thread.CurrentThread.Name);
Console.WriteLine("Thread1: {0}", thread1.ThreadState);
Console.WriteLine("Thread2: {0}", thread2.ThreadState);
}
#endregion
}
}
调试:当Thread1代码逻辑运行到判断语句时Thread2线程已经开启了,所以Thread1需要等待Thread2线程结束才能继续还行后续逻辑
添加超时
- 调用Join的时候,可以设置一个超时,用毫秒或者TimeSpan都可以
- 如果返回true,那就是线程结束了;如果超时了,就返回false.
Thread.Sleep()
- Thread.Sleep() 方法会暂停当前的线程,并等待一段时间
- 注意:
- Thread.Sleep(0)这样调用会导致线程立刻放弃本身当前的时间片,自动将cpu移交过其他线程。
- Thread.Yield()做同样的事情,但是它只会把执行交给同一处理器上的其他线程
- 当等待Sleep或者Join的时候,线程处于阻塞的状态。
- Thread.Sleep(0)这样调用会导致线程立刻放弃本身当前的时间片,自动将cpu移交过其他线程。
- Thread.Yield()做同样的事情,但是它只会把执行交给同一处理器上的其他线程
- 当等待Sleep或者Join的时候,线程处于阻塞的状态。
二、阻塞 Blocking
- 如果线程的执行由于某种原因导致暂定,那么就认为该线程被阻塞了
- 例如在Sleep或者通过Join等待其他线程结束。
- 被阻塞的线程会立刻将其处理器的时间片生成给其他线程,从此就不再消耗处理器时间,直到满足其阻塞条件为止。
- 可以通过ThreadState这个属性来判断线程是否处于被阻塞的状态;
ThreadState
- ThreadState 是一个flags enum, 通过按位的形式,可以合并数据的选项。
- 线程状态图
- 但是它大部分的枚举值是没什么用,下面的代码将ThreadState剥离为四个最有用的值之一:Unstarted、Running、WaitSleepJoin和Stopped
解除阻塞 unblocking
- 当遇到下列四种情况的时候,就会解除阻塞:
- 阻塞条件被满足
- 操作超时(如果设置超时的话)
- 通过Thread.Interrupt() 进行打断
- 通过Thread.Abort() 进行中止
上下文切换
- 当线程阻塞或解除阻塞时,操作系统将执行上下文切换。这会产生少量开销,通常为1或2微妙
I/O-bount vs Compute-bouund (CPU -Bound)
- 一个花费大部分时间等待某事发生的操作称为I/O-bound
- I/O绑定操作通常涉及输入或者输出,但这不是硬性要求:Thread.Sleep() 也被视为I/O-bound
- 相反,一个花费大部分时间执行CPU密集型工作的操作称为Compute-bound
阻塞vs忙等待 (自旋) Block vs Spinnning
- IO-bund 操作的工作方式有两种
- 在当前线程上同步的等待
- Consloe.ReadLine(),Thread.Sleep(),Thread.Join....
- 异步的操作,在稍后操作完成时触发一个回调动作。
- 同步等待的I/O-bound操作将大部分时间花在阻塞线程上。
- 他们也可以周期性在一个循环里进行“打转(自旋)”
- 在忙等待和阻塞方面有一些细微差别。
- 首先,如果您希望条件很快得到满足(可能在几微妙之内),则短暂自旋可能会很有效,因为它避免了,上下文切换的开销和延迟。
- .Net Framework 提供了特殊的方法和类来提供帮助SpinLock 和SpinWait
- 其次,阻塞也不是零成本。这是以为每个线程在生存期间会占用1mb的内存,并会给CLR和操作系统带来持续的管理开销。
- 因此,在需要处理成百上千个并发操作的大量I/O-bound程序的上下本中,阻塞可能会很麻烦
- 所以,此类程序需要使用基于回调的方法,在等待完全撤销其线程。
三、什么是线程安全
本地 vs 共享的状态 Local vs Shared State
Local 本地独立
- CLR为每个线程分配自己的内存栈(Stack),以便使本地变量保持独立。
Shaded 共享
- 如果多个线程都引用到同一个对象的实例,那么他们就共享了数据
-
-
被Lambad表达式或匿名委托所捕获的本地变量,会被编译器转化为字段(field),所以也会被共享
-
-
静态字段(filed)也会在线程间共享数据。
-
线程安全 Thread Safety
- 前三个例子就引出了线程安全这个关键概念 (或者说缺乏线程安全)
- 上述例子的输出实际上是无法确定的:
- 有可能(理论上)“Done”会被打印两次。
- 如果交换Go方法里面语句的顺序,那么“Done”被答应零次的几率会大大增加
- 因为一个线程可能正在评估if,而另一个线程在执行WriteLine语句,它还没来得及把done设为true.
锁定与线程安全 简介Locking & Thread Safety
- 在读取和写入共享数据的时候,通过使用一个互斥锁(exclusive lock),就可以修复前面的例子的问题
- C#使用lock语句来加锁
- 当两个线程同时竞争一个lock的时候(锁可以基于任何引用类型对象),一个线程会等待或阻塞,直到锁变为可用状态。
- 在多线程上下文中,以这种方式避免不确定性的代码叫做线程安全
- Lock不是线程安全的银弹,很容易忘记对字段加锁,lock也会引起一些问题(死锁)
五、向线程传递数据 & 异常处理
传递数据
- 如果你想往线程的启动方法里传递参数,最简单的方式是使用lambda表达式,在里面使用参数调用方法。(例子lambda)
- 甚至可以把整个逻辑都放在lambda里面。(例子mulit-lambda)
- 在C#3.0之前,没有lambda表示式。可以使用Thread的Start方法来传递参数。
- Thread的重载构造函数可以接受下列两个委托之一作为参数:
Lambda表达式与被捕获的变量
- 使用lambda表达式可以简答的给Thread传递参数。但是线程开始后,可能会不小心修改了被捕获的变量,这要多加座椅。(例子captured)
- 解决方案(Captured-solution)
异常处理
- 例如在Sleep或者通过Join等待其他线程结束。
- ThreadState 是一个flags enum, 通过按位的形式,可以合并数据的选项。
- 线程状态图
- 但是它大部分的枚举值是没什么用,下面的代码将ThreadState剥离为四个最有用的值之一:Unstarted、Running、WaitSleepJoin和Stopped
解除阻塞 unblocking
- 当遇到下列四种情况的时候,就会解除阻塞:
- 阻塞条件被满足
- 操作超时(如果设置超时的话)
- 通过Thread.Interrupt() 进行打断
- 通过Thread.Abort() 进行中止
上下文切换
- 当线程阻塞或解除阻塞时,操作系统将执行上下文切换。这会产生少量开销,通常为1或2微妙
I/O-bount vs Compute-bouund (CPU -Bound)
- 一个花费大部分时间等待某事发生的操作称为I/O-bound
- I/O绑定操作通常涉及输入或者输出,但这不是硬性要求:Thread.Sleep() 也被视为I/O-bound
- 相反,一个花费大部分时间执行CPU密集型工作的操作称为Compute-bound
阻塞vs忙等待 (自旋) Block vs Spinnning
- IO-bund 操作的工作方式有两种
- 在当前线程上同步的等待
- Consloe.ReadLine(),Thread.Sleep(),Thread.Join....
- 异步的操作,在稍后操作完成时触发一个回调动作。
- 同步等待的I/O-bound操作将大部分时间花在阻塞线程上。
- 他们也可以周期性在一个循环里进行“打转(自旋)”
- 在忙等待和阻塞方面有一些细微差别。
- 首先,如果您希望条件很快得到满足(可能在几微妙之内),则短暂自旋可能会很有效,因为它避免了,上下文切换的开销和延迟。
- .Net Framework 提供了特殊的方法和类来提供帮助SpinLock 和SpinWait
- 其次,阻塞也不是零成本。这是以为每个线程在生存期间会占用1mb的内存,并会给CLR和操作系统带来持续的管理开销。
- 因此,在需要处理成百上千个并发操作的大量I/O-bound程序的上下本中,阻塞可能会很麻烦
- 所以,此类程序需要使用基于回调的方法,在等待完全撤销其线程。
三、什么是线程安全
本地 vs 共享的状态 Local vs Shared State
Local 本地独立
- CLR为每个线程分配自己的内存栈(Stack),以便使本地变量保持独立。
Shaded 共享
- 如果多个线程都引用到同一个对象的实例,那么他们就共享了数据
-
-
被Lambad表达式或匿名委托所捕获的本地变量,会被编译器转化为字段(field),所以也会被共享
-
-
静态字段(filed)也会在线程间共享数据。
-
线程安全 Thread Safety
- 前三个例子就引出了线程安全这个关键概念 (或者说缺乏线程安全)
- 上述例子的输出实际上是无法确定的:
- 有可能(理论上)“Done”会被打印两次。
- 如果交换Go方法里面语句的顺序,那么“Done”被答应零次的几率会大大增加
- 因为一个线程可能正在评估if,而另一个线程在执行WriteLine语句,它还没来得及把done设为true.
锁定与线程安全 简介Locking & Thread Safety
- 在读取和写入共享数据的时候,通过使用一个互斥锁(exclusive lock),就可以修复前面的例子的问题
- C#使用lock语句来加锁
- 当两个线程同时竞争一个lock的时候(锁可以基于任何引用类型对象),一个线程会等待或阻塞,直到锁变为可用状态。
- 在多线程上下文中,以这种方式避免不确定性的代码叫做线程安全
- Lock不是线程安全的银弹,很容易忘记对字段加锁,lock也会引起一些问题(死锁)
五、向线程传递数据 & 异常处理
传递数据
- 如果你想往线程的启动方法里传递参数,最简单的方式是使用lambda表达式,在里面使用参数调用方法。(例子lambda)
- 甚至可以把整个逻辑都放在lambda里面。(例子mulit-lambda)
- 在C#3.0之前,没有lambda表示式。可以使用Thread的Start方法来传递参数。
- Thread的重载构造函数可以接受下列两个委托之一作为参数:
Lambda表达式与被捕获的变量
- 使用lambda表达式可以简答的给Thread传递参数。但是线程开始后,可能会不小心修改了被捕获的变量,这要多加座椅。(例子captured)
- 解决方案(Captured-solution)
- 阻塞条件被满足
- 操作超时(如果设置超时的话)
- 通过Thread.Interrupt() 进行打断
- 通过Thread.Abort() 进行中止
- 当线程阻塞或解除阻塞时,操作系统将执行上下文切换。这会产生少量开销,通常为1或2微妙
I/O-bount vs Compute-bouund (CPU -Bound)
- 一个花费大部分时间等待某事发生的操作称为I/O-bound
- I/O绑定操作通常涉及输入或者输出,但这不是硬性要求:Thread.Sleep() 也被视为I/O-bound
- 相反,一个花费大部分时间执行CPU密集型工作的操作称为Compute-bound
阻塞vs忙等待 (自旋) Block vs Spinnning
- IO-bund 操作的工作方式有两种
- 在当前线程上同步的等待
- Consloe.ReadLine(),Thread.Sleep(),Thread.Join....
- 异步的操作,在稍后操作完成时触发一个回调动作。
- 同步等待的I/O-bound操作将大部分时间花在阻塞线程上。
- 他们也可以周期性在一个循环里进行“打转(自旋)”
- 在忙等待和阻塞方面有一些细微差别。
- 首先,如果您希望条件很快得到满足(可能在几微妙之内),则短暂自旋可能会很有效,因为它避免了,上下文切换的开销和延迟。
- .Net Framework 提供了特殊的方法和类来提供帮助SpinLock 和SpinWait
- 其次,阻塞也不是零成本。这是以为每个线程在生存期间会占用1mb的内存,并会给CLR和操作系统带来持续的管理开销。
- 因此,在需要处理成百上千个并发操作的大量I/O-bound程序的上下本中,阻塞可能会很麻烦
- 所以,此类程序需要使用基于回调的方法,在等待完全撤销其线程。
三、什么是线程安全
本地 vs 共享的状态 Local vs Shared State
Local 本地独立
- CLR为每个线程分配自己的内存栈(Stack),以便使本地变量保持独立。
Shaded 共享
- 如果多个线程都引用到同一个对象的实例,那么他们就共享了数据
-
-
被Lambad表达式或匿名委托所捕获的本地变量,会被编译器转化为字段(field),所以也会被共享
-
-
静态字段(filed)也会在线程间共享数据。
-
线程安全 Thread Safety
- 前三个例子就引出了线程安全这个关键概念 (或者说缺乏线程安全)
- 上述例子的输出实际上是无法确定的:
- 有可能(理论上)“Done”会被打印两次。
- 如果交换Go方法里面语句的顺序,那么“Done”被答应零次的几率会大大增加
- 因为一个线程可能正在评估if,而另一个线程在执行WriteLine语句,它还没来得及把done设为true.
锁定与线程安全 简介Locking & Thread Safety
- 在读取和写入共享数据的时候,通过使用一个互斥锁(exclusive lock),就可以修复前面的例子的问题
- C#使用lock语句来加锁
- 当两个线程同时竞争一个lock的时候(锁可以基于任何引用类型对象),一个线程会等待或阻塞,直到锁变为可用状态。
- 在多线程上下文中,以这种方式避免不确定性的代码叫做线程安全
- Lock不是线程安全的银弹,很容易忘记对字段加锁,lock也会引起一些问题(死锁)
五、向线程传递数据 & 异常处理
传递数据
- 如果你想往线程的启动方法里传递参数,最简单的方式是使用lambda表达式,在里面使用参数调用方法。(例子lambda)
- 甚至可以把整个逻辑都放在lambda里面。(例子mulit-lambda)
- 在C#3.0之前,没有lambda表示式。可以使用Thread的Start方法来传递参数。
- Thread的重载构造函数可以接受下列两个委托之一作为参数:
Lambda表达式与被捕获的变量
- 使用lambda表达式可以简答的给Thread传递参数。但是线程开始后,可能会不小心修改了被捕获的变量,这要多加座椅。(例子captured)
- 解决方案(Captured-solution)
- I/O绑定操作通常涉及输入或者输出,但这不是硬性要求:Thread.Sleep() 也被视为I/O-bound
- IO-bund 操作的工作方式有两种
- 在当前线程上同步的等待
- Consloe.ReadLine(),Thread.Sleep(),Thread.Join....
- 异步的操作,在稍后操作完成时触发一个回调动作。
- 在当前线程上同步的等待
- 同步等待的I/O-bound操作将大部分时间花在阻塞线程上。
- 他们也可以周期性在一个循环里进行“打转(自旋)”
- 在忙等待和阻塞方面有一些细微差别。
- 首先,如果您希望条件很快得到满足(可能在几微妙之内),则短暂自旋可能会很有效,因为它避免了,上下文切换的开销和延迟。
- .Net Framework 提供了特殊的方法和类来提供帮助SpinLock 和SpinWait
- 其次,阻塞也不是零成本。这是以为每个线程在生存期间会占用1mb的内存,并会给CLR和操作系统带来持续的管理开销。
- 因此,在需要处理成百上千个并发操作的大量I/O-bound程序的上下本中,阻塞可能会很麻烦
- 所以,此类程序需要使用基于回调的方法,在等待完全撤销其线程。
- 首先,如果您希望条件很快得到满足(可能在几微妙之内),则短暂自旋可能会很有效,因为它避免了,上下文切换的开销和延迟。
三、什么是线程安全
本地 vs 共享的状态 Local vs Shared State
Local 本地独立
- CLR为每个线程分配自己的内存栈(Stack),以便使本地变量保持独立。
Shaded 共享
- 如果多个线程都引用到同一个对象的实例,那么他们就共享了数据
-
-
被Lambad表达式或匿名委托所捕获的本地变量,会被编译器转化为字段(field),所以也会被共享
-
-
静态字段(filed)也会在线程间共享数据。
-
线程安全 Thread Safety
- 前三个例子就引出了线程安全这个关键概念 (或者说缺乏线程安全)
- 上述例子的输出实际上是无法确定的:
- 有可能(理论上)“Done”会被打印两次。
- 如果交换Go方法里面语句的顺序,那么“Done”被答应零次的几率会大大增加
- 因为一个线程可能正在评估if,而另一个线程在执行WriteLine语句,它还没来得及把done设为true.
锁定与线程安全 简介Locking & Thread Safety
- 在读取和写入共享数据的时候,通过使用一个互斥锁(exclusive lock),就可以修复前面的例子的问题
- C#使用lock语句来加锁
- 当两个线程同时竞争一个lock的时候(锁可以基于任何引用类型对象),一个线程会等待或阻塞,直到锁变为可用状态。
- 在多线程上下文中,以这种方式避免不确定性的代码叫做线程安全
- Lock不是线程安全的银弹,很容易忘记对字段加锁,lock也会引起一些问题(死锁)
五、向线程传递数据 & 异常处理
传递数据
- 如果你想往线程的启动方法里传递参数,最简单的方式是使用lambda表达式,在里面使用参数调用方法。(例子lambda)
- 甚至可以把整个逻辑都放在lambda里面。(例子mulit-lambda)
- 在C#3.0之前,没有lambda表示式。可以使用Thread的Start方法来传递参数。
- Thread的重载构造函数可以接受下列两个委托之一作为参数:
Lambda表达式与被捕获的变量
- 使用lambda表达式可以简答的给Thread传递参数。但是线程开始后,可能会不小心修改了被捕获的变量,这要多加座椅。(例子captured)
- 解决方案(Captured-solution)
Local 本地独立
- CLR为每个线程分配自己的内存栈(Stack),以便使本地变量保持独立。
Shaded 共享
- 如果多个线程都引用到同一个对象的实例,那么他们就共享了数据
-
-
被Lambad表达式或匿名委托所捕获的本地变量,会被编译器转化为字段(field),所以也会被共享
-
-
静态字段(filed)也会在线程间共享数据。
-
线程安全 Thread Safety
- 前三个例子就引出了线程安全这个关键概念 (或者说缺乏线程安全)
- 上述例子的输出实际上是无法确定的:
- 有可能(理论上)“Done”会被打印两次。
- 如果交换Go方法里面语句的顺序,那么“Done”被答应零次的几率会大大增加
- 因为一个线程可能正在评估if,而另一个线程在执行WriteLine语句,它还没来得及把done设为true.
锁定与线程安全 简介Locking & Thread Safety
- 在读取和写入共享数据的时候,通过使用一个互斥锁(exclusive lock),就可以修复前面的例子的问题
- C#使用lock语句来加锁
- 当两个线程同时竞争一个lock的时候(锁可以基于任何引用类型对象),一个线程会等待或阻塞,直到锁变为可用状态。
- 在多线程上下文中,以这种方式避免不确定性的代码叫做线程安全
- Lock不是线程安全的银弹,很容易忘记对字段加锁,lock也会引起一些问题(死锁)
五、向线程传递数据 & 异常处理
传递数据
- 如果你想往线程的启动方法里传递参数,最简单的方式是使用lambda表达式,在里面使用参数调用方法。(例子lambda)
- 甚至可以把整个逻辑都放在lambda里面。(例子mulit-lambda)
- 在C#3.0之前,没有lambda表示式。可以使用Thread的Start方法来传递参数。
- Thread的重载构造函数可以接受下列两个委托之一作为参数:
Lambda表达式与被捕获的变量
- 使用lambda表达式可以简答的给Thread传递参数。但是线程开始后,可能会不小心修改了被捕获的变量,这要多加座椅。(例子captured)
- 解决方案(Captured-solution)
- 如果多个线程都引用到同一个对象的实例,那么他们就共享了数据
-
-
被Lambad表达式或匿名委托所捕获的本地变量,会被编译器转化为字段(field),所以也会被共享
-
静态字段(filed)也会在线程间共享数据。
线程安全 Thread Safety
- 前三个例子就引出了线程安全这个关键概念 (或者说缺乏线程安全)
- 上述例子的输出实际上是无法确定的:
- 有可能(理论上)“Done”会被打印两次。
- 如果交换Go方法里面语句的顺序,那么“Done”被答应零次的几率会大大增加
- 因为一个线程可能正在评估if,而另一个线程在执行WriteLine语句,它还没来得及把done设为true.
锁定与线程安全 简介Locking & Thread Safety
- 在读取和写入共享数据的时候,通过使用一个互斥锁(exclusive lock),就可以修复前面的例子的问题
- C#使用lock语句来加锁
- 当两个线程同时竞争一个lock的时候(锁可以基于任何引用类型对象),一个线程会等待或阻塞,直到锁变为可用状态。
- 在多线程上下文中,以这种方式避免不确定性的代码叫做线程安全
- Lock不是线程安全的银弹,很容易忘记对字段加锁,lock也会引起一些问题(死锁)
五、向线程传递数据 & 异常处理
传递数据
- 如果你想往线程的启动方法里传递参数,最简单的方式是使用lambda表达式,在里面使用参数调用方法。(例子lambda)
- 甚至可以把整个逻辑都放在lambda里面。(例子mulit-lambda)
- 在C#3.0之前,没有lambda表示式。可以使用Thread的Start方法来传递参数。
- Thread的重载构造函数可以接受下列两个委托之一作为参数:
Lambda表达式与被捕获的变量
- 使用lambda表达式可以简答的给Thread传递参数。但是线程开始后,可能会不小心修改了被捕获的变量,这要多加座椅。(例子captured)
- 解决方案(Captured-solution)
- 有可能(理论上)“Done”会被打印两次。
- 如果交换Go方法里面语句的顺序,那么“Done”被答应零次的几率会大大增加
- 因为一个线程可能正在评估if,而另一个线程在执行WriteLine语句,它还没来得及把done设为true.
- 在读取和写入共享数据的时候,通过使用一个互斥锁(exclusive lock),就可以修复前面的例子的问题
- C#使用lock语句来加锁
- 当两个线程同时竞争一个lock的时候(锁可以基于任何引用类型对象),一个线程会等待或阻塞,直到锁变为可用状态。
- 在多线程上下文中,以这种方式避免不确定性的代码叫做线程安全
- Lock不是线程安全的银弹,很容易忘记对字段加锁,lock也会引起一些问题(死锁)
- 如果你想往线程的启动方法里传递参数,最简单的方式是使用lambda表达式,在里面使用参数调用方法。(例子lambda)
- 甚至可以把整个逻辑都放在lambda里面。(例子mulit-lambda)
- 在C#3.0之前,没有lambda表示式。可以使用Thread的Start方法来传递参数。
- Thread的重载构造函数可以接受下列两个委托之一作为参数:
- 使用lambda表达式可以简答的给Thread传递参数。但是线程开始后,可能会不小心修改了被捕获的变量,这要多加座椅。(例子captured)
- 解决方案(Captured-solution)
- 创建线程时在作用范围内try/catch/finally块,在线程开始执行后就与线程无关了。
- 在WPF、WinForm里,可以订阅全局异常处理事件:
- Application.DispatcherUnhandledException
- Application.ThreadException
- 在通过消息循环调用的程序的任何部分发生未处理的异常(这相当于应用程序处于活动状态时在主线程上运行的所有代码)后,将触发这些异常。(人话:主线程上有未处理的异常就会被触发,UI线程)
- 但是非UI线程上的未处理异常,并不会触发它。
- 而任何线程有任何未处理的异常都会触发 AppDomain.CurrentDomain.UnhandledException
- 默认情况下,你手动创建的线程都是前台线程。
- 只要有前台线程在运行,那么应用程序就会一直处于活动状态。
- 但是后台线程却不行。
- 一旦所有的前台线程停止,那么应用程序就停止了
- 任何的后台线程也会突然终止
- 注意:线程的前台、后台状态与它的优先级无关(所分配的执行时间)
- 可以通过IsBackground属性判断线程是否是后台线程
- 进程以这种形式终止的时候,后台线程执行栈中的finally块就不会被执行了。
- 如果想让它执行,可以在退出程序时使用Join来等待后台线程(如果是你自己创建的线程),或者使用signal construct,如果是线程池...
- 应用程序无法正常退出的一个常见原因是还有活跃的前台线程。
- 线程的优先级(Thread的Priority属性)决定了相对于操作系统中其他活跃线程所占得执行时间
- 优先级分为:
- enum ThreadPriority{Lowest,BelowNormal,Normal,AboveNormal,Highest}
- 提升线程优先级的时候需要特别注意,因为它可能“饿死”其他线程
- 如果想让某线程(Thread)的优先级比其他进程(Process)中线程(Thread)高,那就必须提升进程(Process)的优先级
- 使用System.Diagnostics下的Process类。
- 这可以很好地用于只做少量工作且需要较低延迟的非UI线程。
- 对于需要大量计算的应用程序(尤其是有UI的应用程序),提高进程优先级可能会是其他线程饿死,从而降低整个计算机的速度
- 有时,你需要让某线程一直处于等待的状态,直至接收到其他线程发来的通知。这就叫做signaling(发送信号)
- 最简单的信号结构就是ManualResetEvent。
- 调用上面的WaitOne 方法会阻塞当期的线程,直到另一个线程通过调用Set方法来开启信号。
- 例子signaling
- 调用玩Set之后,信号会“打开”状态。可以通过调用Reset方法将其再次关闭
- 在WPF,UWP,WinForm等类型的程序种,如果在主线程执行耗时的操作,机会导致整个程序无响应。以为主线程同时还需要处理消息循环,而渲染和鼠标键盘事件处理等工作都是消息循环来执行的
- 针对这种耗时的操作,一种流行的做法是启用一个worker线程
- 执行完操作后,再更新到UI
- 富客户端应用的线程模型通常是:
- UI元素和空间只能从创建他们的线程来访问(通常是主UI线程)
- 当想从worker线程更新到UI的时候,你必须把请求交给UI线程
- 比较底层的实现是:
- WPF,在元素的Dispatcher对象上调用BeginInvoke或Invoke。
- WinForm,调用空间的BeginInvoke或Invoke。
- UWP,调用Dispatcher对象上的RunASync或Invoke。
- 所有这些方法都接收一个委托。
- BeginInvoke或RunAsync通过将委托排队到UI线程的消息队列来执行工作。
- Invoke执行相同的操作,但随后会进行阻塞,直到UI线程读取并处理消息。
- 因此,Invoke允许您从方法中获取返回值。
- 如果不需要返回值,BeginInvoke/RunAsync更可取,因为他们不会阻塞调用方,也不会引入死锁的可能性。
- 在System.ComponentModel下有一个抽象类:SynchronizationContext,它使得Thread Marshaling得到泛化。
- 针对移动、桌面(WPF,UWP,WinForms)等富客户端应用的API,他们都定义和实例化了SynchronizationContext的子类
- 可以通过静态属性SynchronizationContext.Current来获取(当运行在UI线程时)
- 捕获该属性让你可以稍后的时候从worker线程向UI线程发送数据
- 调用Post就相当于调用Dispatch或Control上面的BeginInvoke方法
- 还有一个Send方法,它等价于Invoke方法
- 当开始一个线程的时候,将花费几百微秒来组织类似一下的内容:
- 一个新的局部变量栈(Stack)
- 线程池就可以节省这种开销:
- 通过预先创建一个可循环使用的线程池来减少这一开销。
- 线程池对于高效的并行编程和细粒度并发是必不可少的。
- 它允许在不被线程启动的开销淹没的情况下运行短期操作
- 不可以设置线程池的Name
- 池线程都是后台线程
- 阻塞池线程可使性能降级
- 你可以自由的更改池线程的优先级
- 当他释放回池的时候线程池将还原为正常状态
- 可以通过Thread.CurrentThread.IsThreadPoolThread属性来判断是否执行在池线程上
- 最简单、显式的在池线程运行代码的方式就是使用Task。Run
- WCF、Remoting、ASP.NET、AsMX Web Services 应用服务器
- System.Timers.Timer、System.Threading.Timer
- 并行编程结构
- BackgroundWorker(现在很多余)
- 异步委托(现在很多余)
- 线程池提供了另一个功能,即确保临时超出计算-Bound的工作不会导致CPU超额订阅
- CPU超额订阅:活跃的线程超过CPU的核数,操作系统就需要对线程进行时间切片
- 超额订阅对性能影响很大,时间切片需要昂贵的上下文切换,并且可能使CPU缓存失效,而CPU缓存对于现代处理器的性能至关重要
- CLR通过对任务排队并对其启动进行节流限制来避免线程池中的超额订阅
- 它首先运行尽可能多的并发任务(只要还有CPU核),然后通过爬山算法调整并发级别,并在特定方向上不断调整工作负载。
- 如果吞吐量提高,它将继续朝同乙方向(否则将反转)
- 这确保它始终追随最佳性能曲线,即使面对计算机上竞争的进程活动时也是如此
- 如果下面两点能够满足,那么CLR的策略将发挥出最佳效果:
- 工作项大多是短时间的(<250毫秒),因此CLR有很多机会进行测量和调整。
- 大部分时间都被阻塞的工作项不会主宰线程池
- 线程(Thread)是用来创建并发(concurrency)的一种低级工具,它还有一些限制,尤其是:
- 虽然开始线程的时候可以方便的传入数据,但是当Join的时候,很难从线程获得返回值。
- 可能需要设置一些共享字段。
- 如果操作抛出异常,捕获和传播该异常都很麻烦
- 无法告诉线程在结束时开始做另外的工作,你必须进行Join操作(在进程中阻塞当前线程)
- 虽然开始线程的时候可以方便的传入数据,但是当Join的时候,很难从线程获得返回值。
- 很难使用较小的并发(concurrent)来组建大型的并发。
- 导致了对手动同步的更大以来以及随之而来的人问题。
- Task类可以很好的解决上述问题
- Task是一个相对高级的抽象:它代表了一个并发操作(concurrent)
- 该操作可能由Thread支持,或不由Thread支持
- Task是可组合的(可使用Continuation把他们串成链)
- Tasks可以使用线程池来减少启动延迟
- 使用TaskCompletionSource,Task可以利用回调的方式,在等待I/O绑定操作时完全避免线程
- Task类在System.Threading.Tasks 命名空间下。
- 开始一个Task最简单的办法就是使用Task.Run (.Net4.5, 4.0的时候是Task.Factory.StartNew这个静态方法:
- 传入一个Action委托即可(例子task))
- Task默认使用线程池,也就是后台线程
- 当主线程结束的时候,你所创建的所有tasks都会结束(例子task)
- Task.Run返回一个Task对象,可以使用它来监听其过程
- 在Task.Run之后,我们没有调用Start,因为该方法创建的是“热”任务(hot task)
- 可以通过Task的构造函数来创建“冷”任务(cold task),但是很少这样做
- 在Task.Run之后,我们没有调用Start,因为该方法创建的是“热”任务(hot task)
- 可以通过Task的Status属性来跟踪task的执行状态
- 调用task的Wait方法会进行阻塞直到操作完成
- 相当于调用thread上的Join方法
- Wait 也可以让你制定一个超时时间和一个取消令牌来提前结束等待。
- 默认情况下,CLR在线程池中运行Task,这非常适合短时间运行的Compute-Bound类工作。
- 针对长时间运行的任务或者阻塞操作(例如前面的例子),你可以不采用线程池(例子longRunning)
- 如果同时运行多个long-running tasks(尤其是其中有处于阻塞状态的),那么将会受很大影响,这时有比TaskCreationOptions.LongRunning更好的办法:
- 如果任务是IO-Bound,TaskCompletionSource和异步函数可以让你用回调(Coninuations)代替线程来实现并发。
- 如果任务是Compute-Bound,生产者/消费者队列允许你对任务的并发性进行限流,避免把其他线程和进程饿死、
- Task有一个泛型子类叫做Task
,它允许发出一个返回值。 - 使用Func
委托或兼容的Lambda表达式来调用Task.Run就可以得到Task - 随后,可以通过Result属性来获得返回的结果
- 如果这个task还没有完成操作,访问Result属性会阻塞该线程直到该task完成操作。
- 例子(tresult
- , prime)
- Task
可以看做是一种所谓的“未来/许诺”(future、promise),在它里面包裹了一个Result,在稍后的时候就会变得可用。 - 在CTP版本的时候。Task
实际上叫做Future
- 与Thread不一样,Task可以很方便的传播异常
- 如果你的task里面抛出一个未处理的异常(故障),那么该异常就会重新被抛出给:
- 调用wait()的地方
- 访问了Task
的Result属性的地方。 - 例子(exception)
- 如果你的task里面抛出一个未处理的异常(故障),那么该异常就会重新被抛出给:
- CLR将异常包裹在AggregateException里,以便在并行编程场景中发挥很好的作用
- 无需重新抛出异常,通过Task的IsFaulted和IsCanceled属性也可以检测出Task是否发生了故障:
- 如果两个属性都返回false。那么久没有错误发生。
- 如果IsCanceled为true,那就说明给一个OpoerationCanceledException为该Task抛出了。
- 如果IsFaulted为true,那就说明另一个类型的异常被抛出了,而Exception属性也将指明错误
- 自治的,“设置完就不管了”的Task,就是指不通过调用Wait()方法,Result属性或者continuation进行回合的任务。
- 针对自治的Task,需要像Thread一样,显式的处理异常,避免发生“悄无声息的故障”。
- 自治Task上未处理的异常被称为未观察到的异常
- 可以通过全局的TaskScheduler.UnobservedTaskException来订阅未观察到的异常。
- 关于什么是“未观察到的异常”,有一些细微的差别:
- 使用超时进行等待的Task,如果在超市后发生故障,那么它将产生一个“未观察到的异常”。
- 在Task发生故障后,如果访问Task的Exception属性,那么该异常就被认为是“已观察到的”。
- 一个Continuation会对Task说:“当你结束的时候,继续做点其他的事”
- Continuation通常是通过回调的方式实现的
- 当操作一结束,就开始执行
总结
提示:这里对文章进行总结:
例如:以上就是今天要讲的内容,本文仅仅简单介绍了pandas的使用,而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。



