ASP.Net Core异步编程

ASP.Net Core异步编程

概念

什么是异步编程?

异步编程是可以让程序并行运行的一种手段,其可以让程序中的一个工作单元与主应用程序线程分开独立运行,并且在工作单元运行结束后,会通知主应用程序线程它的运行结果或者失败原因。使用异步编程可以提高应用程序的性能和响应能力。[^1]

应当注意的是,所谓的异步编程能提高效率这句话并不严谨,严格的来说它是利用了等待时间以优化整体的时间效率,而对于其中任意一项工作其本来的效率并没提高。

如果你对此概念的理解还是十分抽象,下面我们用一道小学数学题来举例。

小明的妈妈做饭要a分钟,烧水要b分钟,请问小明妈妈烧水并做饭一共要多长时间(a与b均大于0)?我们不妨记最终所用时间为T,则有如下情况:

  • 对于传统的同步编程来讲,小明妈妈要先烧水然后做饭或者先做饭然后去烧水,烧水或做饭的时间内是无法做其他事情的,这个等待的过程我们称为阻塞的。这样所用的总时间如下
\[T_1 = a + b \]
  • 然而对于异步编程,就是让小明妈妈将烧水壶通电进行烧水,烧水由烧水壶负责,而小明妈妈可以一边做饭一边等水烧开。简单来讲就是在等待一件事情完成的同时,利用这段空闲时间去做其他事情,这个过程是非阻塞的。所以所用时间如下:
\[T_2 = \max (a,b) \]

然而由简单的数学知识可知

\[x \le \max (a,b) < a+b,\space x\in \left \{ a,b \right \} \]

所以问题来了:对于烧水或做饭的效率提高了吗?答案是没有。因为烧水仍然要b分钟,做饭仍然要a分钟。然而对于整体的效率却得到了提升,就如上方公式所表示的那样。

async\await关键字

异步方法的定义

在.net中所谓的异步方法,一般是指async关键字修饰的方法。该方法有如下特点:

  • 异步方法的返回值一般是Task<T>,T是真正的返回值类型,如Task<int>。即使方法没有返回值,也最好把返回值声明为非泛型的Task。(按钮等控件事件响应方法用void)
  • 异步方法名字以Async结尾。
  • 调用异步方法时,一般方法前面加上await关键字,这样返回值就是泛型指定的T类型。
  • 一个方法中如果有await调用的异步方法,那么该方法也必须是async修饰的异步方法。

下面我们利用C#自带的异步同步方法写入再读取txt文件

同步方法:

//同步
using System;

namespace ConsoleApp1
{
    class Program
    {

        static void Main(string[] args)
        {
            string filename = "test.txt";   //读取/写入文件名
            File.WriteAllText(filename, "hello,world");
            string str = File.ReadAllText(filename);
            Console.WriteLine(str);
        }
    }
}

异步方法:

//异步
using System;

namespace ConsoleApp1
{
    class Program
    {

        static async Task Main(string[] args)   //注意这里Main函数变化
        {
            string filename = "test.txt";   //读取/写入文件名
            //如果此处不写await,此处不会等待就进行读取。当数据多的时候,一边写一边读,由于写入操作占用文件,当执行下方读取语句的时候程序会报错。
            await File.WriteAllTextAsync(filename, "hello");
            /* 
             * 对于ReadAllTextAsync返回值是Task<string>,添加await后会自动把string从Task拿出来
             * 否则要这样写
             * Task<string> t = File.ReadAllTextAsync(filename);
             * string str = await t;
             */
            string str = await File.ReadAllTextAsync(filename);
            Console.WriteLine(str);
        }
    }
}

官方给的方法有了,那么接下来我们写一个自己的异步方法来获取百度的html

using System;

namespace ConsoleApp1
{
    class Program
    {

        static async Task Main(string[] args)
        {
            int a = await DownloadHtmlAsync("https://www.baidu.com", @"test.txt");
            Console.WriteLine("写入完毕!字符串长度为{0}",a);
        }

        //获取百度htnl并写入文件中,返回html字符串长度
        static async Task<int> DownloadHtmlAsync(string url, string filename)
        {
            HttpClient client = new HttpClient();   //.net5及以上
            string html = await client.GetStringAsync(url);
            await File.WriteAllTextAsync(filename, html);
            return html.Length;
        }
    }
}

输出结果为

写入完毕!字符串长度为9193

打开生成的可执行文件同一目录下的test.txt发现果然获取到了。Html代码太长,此处我就不放出来了。

那么还会有人问,如果某些地方不支持异步方法,那怎么办呢。其实我们只需要在异步方法后面加.Wait().Result就可以了(不推荐),代码如下:

//此处为了简洁仅给出了Main函数部分
static void Main(string args[])         //注意此处的Main我们并没用async关键字
{
	File.WriteAllTextAsync("text.txt", "hello,world").Wait();
	string str = File.ReadAllTextAsync(@"test.txt").Result;
	Console.WriteLine(str);
}

尽管这种方式可以达成目的,但是还是不推荐,因为这种方式可能会面临死锁的风险。

死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。[^2]

异步方法的线程委托

在一些情况下我们可能会将异步方法放到线程池来执行。

如果该方法是用正则表达式写的匿名方法的话,则只需要在前面使用async关键字即可。

ThreadPool.QueueUserWorkItem(async (obj) =>{
	while(true)
	{
		await File.WriteAllTextAsync(@"test.txt", "hello,world");
	}
});

async\await原理

我们编译如下代码获取百度Html,并向test.txt写入内容做示范

using System;
using System.Net.Http;

namespace ConsoleApp1
{
    class Program
    {

        static async Task Main(string []args)         //注意此处的Main我们并没用async限定符
        {
            using (HttpClient client = new HttpClient())
            {
                string html = await client.GetStringAsync("https://www.baidu.com");
                Console.WriteLine(html);
            }
            string txt = "hello,world";
            string filename = "test.txt";
            await File.WriteAllTextAsync(filename, txt);
            string str = await File.ReadAllTextAsync(filename);
            Console.WriteLine("文件内容: {0}",str);
        }


    }
}

然后利用ILSpy反编译生成的Dll文件,查看编译器到底给我们做了什么工作来探究async与await背后的原理。

ILSpy可以从GitHub上下载

GitHub - icsharpcode/ILSpy
https://github.com/icsharpcode/ILSpy

将ILSpy版本设置成C#4.0

然后发现有两个Main函数

通过查看代码我们便知道,真正的Main实际上是void类型的,这是编译器帮我们搞定的,这个Main中调用了写代码的时候被async修饰返回值为Task的Main函数。

而通过查看<Main>d_0的代码我们可以分析出async与await的底层原理:

  • async的方法会被C#编译器编译成一个类,会主要根据await调用切分成多个状态,对async方法的调用会被拆分为MoveNext的调用。
  • await看似是等待,实际上编译后没有等待。await调用的等待期间,.net会把当前的线程返回给线程池,等异步方法调用执行完毕后,框架会从线程池再取出来一个线程执行后续代码。此外这里还进行了优化,到要等待的时候如果发现已经执行结束了,那就没必要切换线程了,剩下的代码继续在之前的线程上执行。

我们为了验证上面await的过程可以去尝试打印线程的ID,只要出现线程ID不同即可证明。代码如下:

//利用异步写入一个很大的此字符串增加时间以防止线程ID相同(字符串较小ID可能会相同)
static async Task Main(string []args)
{
	Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
	StringBuilder sb = new StringBuilder();     //StringBuilder需要using System.Text
	for(int i = 0; i < 10000; i++)
	{
		sb.Append("XXXXXX");
	}

	await File.WriteAllTextAsync(@"test.txt", sb.ToString());
	Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
}

在我的PC上运行结果如下,很显然进程ID不一样。

1
10

异步方法不等于多线程

我们来执行下一段代码

using System;
using System.Text;

namespace ConsoleApp1
{
    class Program
    {

        static async Task Main(string []args)
        {
            Console.WriteLine("之前ID: "+Thread.CurrentThread.ManagedThreadId);
            await CalcAsync(5000);
            Console.WriteLine("之后: "+Thread.CurrentThread.ManagedThreadId);
        }

        //n个随机数相加
        static async Task<double> CalcAsync(int n)
        {
            Console.WriteLine("CalcAsync: " + Thread.CurrentThread.ManagedThreadId);
            double result = 0;
            Random random = new Random();
            for(var i = 0; i < n; i++)
                result += random.NextDouble();

            return result;
        }


    }
}

查看输出结果中的线程ID发现并没有变。

实际上,异步方法并不会自动在新的线程中执行,除非把代码放到新线程中去。看到这里你可能会问,为什么上文中的线程ID变了呢?

那是因为我们在上文中用当都是内部方法,其实现本就带了Task。

如果我们将上面的CalcAsync方法改成下面的,就能看到进程ID改变了。

static async Task<double> CalcAsync(int n)
{
	return await Task.Run(() =>
	{
		Console.WriteLine("CalcAsync: " + Thread.CurrentThread.ManagedThreadId);
		double result = 0;
		Random random = new Random();
		for (var i = 0; i < n; i++)
			result += random.NextDouble();
		return result;
	});
}

为什么有的异步方法没标async

下面来看这两种方法:

static async Task<string> ReadFileAsync(int num)
{
	if (num == 0)
		return await File.ReadAllTextAsync("test1.txt");
	else if (num == 1)
		return await File.ReadAllTextAsync("test2.txt");
	else
		throw new ArgumentException("num invalid");
}
static Task<string> ReadFileAsync(int num)
{
	if (num == 0)
		return File.ReadAllTextAsync("test1.txt");
	else if (num == 1)
		return File.ReadAllTextAsync("test2.txt");
	else
		throw new ArgumentException("num invalid");
}

首先要说明的是,这两种方法都是符合语法规范的并且结果一致。第一种方法,把Task的string拆出来然后返回时又封装了回去,是一个异步方法;而第二种在调用时相当于直接访问的返回的Task,是一个普通的方法,但使用起来是异步的(相当于直接用File.ReadAllTextAsync)。

然而对于异步方法来讲,通过上文中的反编译可知,异步方法会生成一个类,占用更多的线程,运行效率没有普通方法高。第二种方法很好的避免了这个现象,因此必要时我们可以采用第二种方法。

但如果不是简单地将内部的Task返回出来,而是要对值进行某些操作然后再返回的话(比如将string字符串后面再加上一段),那么只能老实地去使用async与await关键字了。

static async Task<string> ReadFileAsync(int num)
{
	if (num == 0)
	{
		string s = await File.ReadAllTextAsync("test1.txt");
		s += "123";
	}
	else if (num == 1)
	{
		string s = await File.ReadAllTextAsync("test2.txt");
		s += "123";
	}
	else
		throw new ArgumentException("num invalid");
}

异步方法不要使用Sleep

如果想要在异步方法中暂停一段时间,不要用Sleep方法,因为它会阻塞调用线程,降低并发。

Thread.Sleep(3000);		// 暂停3000ms,会阻塞线程调用

如果要实现类似效果的话,可以用await关键字加Delay方法 ,用法如下

await Task.Delay();		//异步暂停3000ms

CancellationToken参数

在以前版本的.net给出了Thread.Abort()方法,但这种方法是强制结束线程的,可能产生一些问题,尽量不要去使用它。

有时需要提前终止任务,如请求超时,用户取消请求。很多异步方法都有CancellationToken参数用于提请终止执行的信号。

CancellationToken是一个结构体,它有如下几个成员

  • None
  • bool IsCancellationRequested 是否取消
  • (*)Register(Action callback)注册取消监听
  • ThrowIfCancellationRequested()如果任务被取消执行到这句话就抛出异常

在创建CancellationToken结构体时,一般不是通过new关键字去完成的,而是通过CancellationTokenSource类去创建的。

CancellationTokenSource有几个重要的方法:

  • CancelAfter()超时后发出取消信号
  • Cancel()发出取消信号

我们利用上面的知识编写一个方法,要求下载一个网页Html n次,但是在一秒钟后会被取消,当然这个过程是异步的。

static async Task Main(string []args)
{
	CancellationTokenSource cts = new CancellationTokenSource();
	cts.CancelAfter(1000);      //1秒后取消操作
	CancellationToken cToken = cts.Token;
	await DownloadHtml("https://www.baidu.com", 100, cToken);
}

static async Task DownloadHtml(string url, int n, CancellationToken cancellationToken)
{
	using(HttpClient client = new HttpClient())
	{
		for(var i = 0; i < n; i++)
		{
			string html = await client.GetStringAsync(url);
			Console.WriteLine($"{DateTime.Now}:{html}");
			if (cancellationToken.IsCancellationRequested)
			{
				Console.WriteLine("请求被取消!");
				break;
			}
		}
	}
}

接着我们改变下需求,要求一秒钟后抛出异常,代码可以这样写

static async Task DownloadHtml(string url, int n, CancellationToken cancellationToken)
{
	using(HttpClient client = new HttpClient())
	{
		for(var i = 0; i < n; i++)
		{
			string html = await client.GetStringAsync(url);
			Console.WriteLine($"{DateTime.Now}:{html}");
			cancellationToken.ThrowIfCancellationRequested();
		}
	}
}

当然还有一种方式是利用了GetAsync()方法的

static async Task DownloadHtml(string url, int n, CancellationToken cancellationToken)
{
    using (HttpClient client = new HttpClient())
    {
        for (var i = 0; i < n; i++)
        {
            var resp = await client.GetAsync(url, cancellationToken);
            string html = await resp.Content.ReadAsStringAsync();
            Console.WriteLine($"{DateTime.Now}:{html}");
        }
    }
}

那么这两种方式有什么区别呢?如果网站下载特别慢,对于第一种方式要下载完网页才会执行抛出异常的语句,实际上一秒钟后不一定会抛出异常;而第二种方式,则一秒钟后一定会抛出异常。

Task类与WhenAll

Task类的重要方法:

  • Task<Task> WhenAny(IEnumerable<Task> tasks)等,任何一个Task完成,Task就完成。
  • Task<TResult[]> WhenAll<TResult>(params Task<TResult>[] tasks)等,所有Task完成,Task才完成。用于等待多个任务执行结束但是不在乎它们的执行顺序。
  • FromResult()创建普通数值的Task对象

在这里我们主要来看WhenAll的使用

static async Task Main(string[] args)
{
    Task<string> t1 = File.ReadAllTextAsync(@"test1.txt");
    Task<string> t2 = File.ReadAllTextAsync(@"test2.txt");
    Task<string> t3 = File.ReadAllTextAsync(@"test3.txt");

    string[] strs = await Task.WhenAll(t1, t2, t3);
    for (var i = 0; i < 3; i++)
        Console.WriteLine(strs[i]);
}

异步的其他问题

接口中的异步方法

async是编译器为异步方法中await代码进行分段处理的,而一个异步方法是否修饰了async对于调用者来讲没有区别,因此对于接口中的方法或者抽象方法不能修饰为async。

interface ITest
{
    Task<int> GetCharCount(string file);                //正确
    async Task<int> GetCharCountAsync(string file);     //错误,接口中的方法不能用async修饰
}
class Test : ITest
{
    public async Task<int> GetCharCount(string file)
    {
        string s = await File.ReadAllTextAsync(file);
        return s.Length;
    }
}

异步与yield

yield不仅能简化数据的返回,而且还可以让数据处理“流水线化”提升性能。

关于yield的使用可以参考

yield 上下文关键字 - C# 参考 | Microsoft Docs
https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/yield

C#中yield用法 - 大西瓜3721 - 博客园
https://www.cnblogs.com/Alex80/p/7404621.html

在旧版C#中,async方法中不能用yield。从C#8.0开始,把返回值声明为async IAsyncEnumerable(不要带Task)然后遍历的时候用await foreach()即可。

static async Task Main(string[] args)
{
    await foreach (var s in Test())				//注意await
        Console.WriteLine(s);
}
static async IAsyncEnumerable<string> Test()	//注意没Task
{
    yield return "hello";
    yield return "world";
}

SynchronizationContext问题

在ASP.Net Core和控制台项目中没有SynchronizationContext因此不用去管ConfigureAwait(false)等。

注意事项

在开发时不要把同步方法和异步方法混用。

结束

异步方法的基本内容大概就这些了,本文章可以看作教程同时也是笔者的学习笔记,感谢 杨中科老师提供的.Net Core课程

参考

[^1]

迷彩风情.认识异步编程[Z].知乎,2020-03-28
https://zhuanlan.zhihu.com/p/119403370

[^2]

死锁[Z].百度百科,2022-08-20
https://baike.baidu.com/item/%E6%AD%BB%E9%94%81/2196938?fr=aladdin