在上一篇通信协议碰到了多线程，阻塞、非阻塞、锁、信号量...，会碰到很多问题。因此我感觉很有必要研究多线程与异步编程。
我说明一下这个例子。
这是一个演示异步编程的例子。
Main方法中，以一发即忘的方式调用异步方法StartJob()。PrintCurrentTime()输出时间。一发即忘的方式调用异步方法时，在异步方法中碰到阻塞时，主线程返回同步方法中继续执行。而异步方法在另一个线程中继续执行。internal class Program
{
static void Main(string[] args)
{
while (true)
{
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Enter 'time' to get current time or 'job [name]' to start a job:");
string input = Console.ReadLine();
if (input.StartsWith("time"))
{
// 输出当前时间
PrintCurrentTime();
}
else if (input.StartsWith("job"))
{
// 启动一个异步任务，执行指定的工作
string[] parts = input.Split(new char[] { ' ' }, 2);
string jobName = parts.Length > 1 ? parts[1] : string.Empty;
StartJob(jobName);
}
else
{
Console.WriteLine("Invalid input. Please try again.");
}
}
}
static void PrintCurrentTime()
{
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Current time: {DateTime.Now}");
}
static async void StartJob(string jobName)
{
// 获取主线程的线程 ID
int mainThreadId = Thread.CurrentThread.ManagedThreadId;
// 检查是否在主线程上
bool onMainThread = Thread.CurrentThread.ManagedThreadId == mainThreadId;
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Starting job '{jobName}'. This will take 10 seconds...");
// 输出主线程上下文移动情况
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Main thread context moved to new thread: {(!onMainThread)}");
await Task.Delay(10000); // 模拟任务需要10秒钟完成
// 输出任务完成信息及上下文移动情况
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Job '{jobName}' completed. Main thread context moved to new thread: {(!onMainThread)}");
}
}
一个方法从一个线程代码栈被切换，或者说被剪切到另一个线程代码栈上去，可以称为上下文流转。
这对于理解异步编程是一个重要的点。
但由于上面的程序缺少必要变量，我需要在不同位置加几个变量，来展示上下文确实被移动了。
static async void StartJob(string jobName)
{
int mainThreadId = Thread.CurrentThread.ManagedThreadId;
// 检查是否在主线程上
bool onMainThread = Thread.CurrentThread.ManagedThreadId == mainThreadId;
...
}
可以看到onMainThread一直为False,这个变量从线程1移动到线程5。
而且bool是值类型，在栈上面，这说明StartJob这段代码确实移动到线程5的栈上面去了。(每个线程都有一个调用栈)
想要再进一步，更清晰的话说明上下文流转的话，那就得监视这两个线程栈的内容了。万幸的是 vs提供了这个功能，调试 > 窗口 > 并行堆栈。
命中断点时，StartJob方法在主线程24876上
10秒后再次命中，StartJob方法跑到了任务线程上。而主线程现在在Main函数的Console.ReadLine()那里阻塞
代码阻塞与线程阻塞
在上面的例子中我们引出两种现象，代码阻塞与线程阻塞。
代码阻塞时，线程不一定阻塞，原线程没有阻塞，去执行别的代码了，而由新线程接手当前上下文和调用栈阻塞在这里，比如这里的await Task.Delay(10000)。
代码阻塞时线程也可能阻塞，比如lock(lockObj)和Console.ReadLine()。
为了方便，我们姑且这样命名吧
为什么有两个箭头
这里为什么有线程24666和27548两个NET TP Worker（.NET Thread Pool (TP) Worker）?据chatGPT解释，Delay语句在线程池中找了一个线程去执行，一旦延迟时间到达，StartJob会在其中一个线程池线程上恢复执行。计时是一个线程，恢复上下文是另一个线程。Delay就代表了我们的那个耗时线程（不是异步方法所在线程）。
既然有两个线程的联动，其中就出现了一些熟悉的东西。信号量Semaphore,一次性信号量的消耗TrySetResult，但详细过程我还不清楚。
MSDN上的例子也是这样
原来把异步方法的上下文移动到新线程N，保证主线程不阻塞（脱离主线程U）。然后N用第三个线程C执行耗时任务，最后把C结果给位于N中的上下文。
站在代码编写者的角度，不特意去看线程的话，就不会注意到异步方法的上下文从一个线程跑到另一个线程上去了。这就是所谓的以同步的方式进行异步编程。
那么线程N的执行就明晰了。先保存上下文，然后启用新线程C进行耗时任务，并阻塞。等C使用信号量或其他什么通知N时，N再根据C的结果继续执行。
可以这样总结
async和await是一个语法糖。我列出几种可能的异步的实现
async语法糖的实现方式StartJob将会被编译成一个同步方法StartJobAsync和一个状态机StartJobAsyncMachine。internal class Program
{
...
internal static void StartJobAsync(string jobName)
{
StartJobAsyncMachine stateMachine = new StartJobAsyncMachine();
stateMachine.builder = AsyncVoidMethodBuilder.Create();
stateMachine.jobName = jobName;
stateMachine.state = -1;
stateMachine.builder.Start(ref stateMachine);
}
public sealed class StartJobAsyncMachine : IAsyncStateMachine
{
public int state;
public AsyncVoidMethodBuilder builder;
private TaskAwaiter taskAwaiter;
//形参会编译成public字段
public string jobName;
//被新线程使用的局部变量会编译成private字段
private bool onMainThread;
private void MoveNext()
{
int num = state;
try
{
TaskAwaiter awaiter;
if (num != 0)
{
// 获取主线程的线程 ID
int mainThreadId = Thread.CurrentThread.ManagedThreadId;
// 检查是否在主线程上
onMainThread = Thread.CurrentThread.ManagedThreadId == mainThreadId;
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Starting job '{jobName}'. This will take 10 seconds...");
// 输出主线程上下文移动情况
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Main thread context moved to new thread: {(!onMainThread)}");
awaiter = Task.Delay(10000).GetAwaiter();
if (!awaiter.IsCompleted)
{
num = (state = 0);
taskAwaiter = awaiter;
StartJobAsyncMachine stateMachine = this;
builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
return;
}
}
else
{
awaiter = taskAwaiter;
taskAwaiter = default(TaskAwaiter);
num = (state = -1);
}
awaiter.GetResult();
// 输出任务完成信息及上下文移动情况
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Job '{jobName}' completed. Main thread context moved to new thread: {(!onMainThread)}");
}
catch (Exception exception)
{
state = -2;
builder.SetException(exception);
return;
}
state = -2;
builder.SetResult();
}
void IAsyncStateMachine.MoveNext()
{
this.MoveNext();
}
private void SetStateMachine(IAsyncStateMachine stateMachine)
{
}
void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
{
this.SetStateMachine(stateMachine);
}
}
}
StartJobAsync的调用和原方法等效。我在Main中在加一种指令jobMachine调用StartJobAsync。原来的改为job空格
else if (input.StartsWith("jobMachine "))
{
// 启动一个异步任务，执行指定的工作
string[] parts = input.Split(new char[] { ' ' }, 2);
string jobName = parts.Length > 1 ? parts[1] : string.Empty;
StartJobAsync(jobName);
}
这种方法到底叫协程还是异步迭代器,我不太分得清，但目的是能够达到的，我暂且就叫做协程好了。
虽然这种做法就像脱裤子放屁，因为协程最后也会编译成状态机。这个例子主要是为了演示直观。
理论上，C#中的异步/等待（async/await）语法并不是直接编译成协程的，而是由编译器生成状态机（state machine）来管理异步操作。但是，我们可以通过理解协程的工作原理以及C#异步/等待模型的特性，来描绘一种可能的编译结果。
这里我写了一个基于协程的异步的实现。效果和原来的等同。
async方法生成一个协程。而且在异步方法嵌套时，那么async方法内部的async方法在编译时就不需要开一个新线程了。要不然得多少线程。internal class Program
{
static void Main(string[] args)
{
while (true)
{
...
else if (input.StartsWith("jobCorotine "))
{
// 启动一个异步任务，执行指定的工作
string[] parts = input.Split(new char[] { ' ' }, 2);
string jobName = parts.Length > 1 ? parts[1] : string.Empty;
StartJobAsync_2(jobName);
}
...
}
}
#region 异步协程
static void StartJobAsync_2(string jobName)
{
StartJobAsyncCorotine startJobCorotine = new StartJobAsyncCorotine();
startJobCorotine.jobName = jobName;
var enumerator = startJobCorotine.DelayedOperations();
var iterator = enumerator.GetEnumerator();
bool next = false;
while (true)
{
next = iterator.MoveNext();
if (!iterator.Current.IsCompleted)
{
//异步方法中存在耗时任务，切换到新线程
break;
}
next = false;
}
if (next == false)
{
return;
}
//异步方法存在耗时任务,切换上下文到新线程
Task.Run(() =>
{
do
{
if (!iterator.Current.IsCompleted)
{
//创建耗时任务线程进行耗时任务
Task.Run(() =>
{
iterator.Current.GetResult();
}).Wait();
}
}
while (iterator.MoveNext());
});
}
public sealed class StartJobAsyncCorotine
{
//形参因为需要运行时赋值，只能写成字段的形式
public string jobName;
public int Count = 1;
public IEnumerable<TaskAwaiter> DelayedOperations()
{
TaskAwaiter awaiter1;
// 获取主线程的线程 ID
int mainThreadId = Thread.CurrentThread.ManagedThreadId;
// 检查是否在主线程上
bool onMainThread = Thread.CurrentThread.ManagedThreadId == mainThreadId;
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Starting job '{jobName}'. This will take 10 seconds...");
// 输出主线程上下文移动情况
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Main thread context moved to new thread: {(!onMainThread)}");
awaiter1 = Task.Delay(10000).GetAwaiter(); // 模拟任务需要10秒钟完成
//出去判断这是否是耗时任务以切换线程
yield return awaiter1;
// 输出任务完成信息及上下文移动情况
Console.WriteLine($"(Thread ID: {Thread.CurrentThread.ManagedThreadId}) Job '{jobName}' completed. Main thread context moved to new thread: {(!onMainThread)}");
}
}
#endregion
}
这真不需要多说，通过闭包进行捕获上下文真的是太常见了，Ajax中用到吐🤮
StartJob是没有返回值的，假如我们需要一个返回值呢，比如一个bool，用于判断接下来的执行流程。
调用异步方法StartJob的同步方法Main之间存在着绝对的分界线——两个线程。同步方法不会被交给异步方法中的那个新线程，没法在同步方法中以同步的方式进行异步编程。
唯一的一点看头是，至少Task还给我们留下了一个回调ContinueWith可用。但条件允许的话，何不把回调的内容写在异步方法内部呢？