shanzm-2020年3月7日 23:12:53

0.背景引入

现在的.net异步编程中,一般都是使用 基于任务异步模式(Task-based Asynchronous Pattern,TAP)实现异步编程

可参考微软文档:使用基于任务的异步模式

基于任务的异步模式,是使用 System.Threading.Tasks 命名空间中的 System.Threading.Tasks.Task<TResult>System.Threading.Tasks .Task类型实现异步编程,

配合着C#5.0(.net 4.5)中添加的两个关于异步编程的关键字asyncawait,可以快速的实现异步操作。



1.async和await基本语法

1.1 简介

在C#5.0(.net 4.5)中添加了两个关于异步编程的关键字asyncawait

两个关键字可以快速的创建和使用异步方法。asyncawait关键字只是编译器功能,编译后会用Task类创建代码,实现异步编程。其实只是C#对异步编程的语法糖,本质上是对Task对象的包装操作。

所以,如果不使用这两个关键字,也可以用C#4.0中Task类的方法来实现同样的功能,只是没有那么方便。(见:.NET异步程序设计之任务并行库)

1.2 具体使用方法

  1. async:用于异步方法的函数名前做修饰符,处于返回类型左侧。async只是一个标识符,只是说明该方法中有一个或多个await表达式,async本身并不创建异步操作。

  2. await:用于异步方法内部,用于指明需要异步执行的操作(称之为await表达式),注意一个异步方法中可以有多个await表达式,而且应该至少有一个(若是没有的话编译的时候会警告,但还是可以构建和执行,只不过就相当于同步方法而已)。

    其实这里你有没有想起Task类中为了实现延续任务而使用的等待者,比如:使用task.GetAwaiter()方法为task类创建一个等待者(可以参考;3.3.2使用Awaiter)。await关键字就是基于 .net 4.5中的awaiter对象实现的。

  3. 总而言之,若是有await表达式则函数一定要用async修饰,若是使用了async修饰的方法中没有await表达式,编译的时候会警告!

1.3 返回值类型

  1. 使用asyncawait定义的异步方法的返回值只有三种:Task<T>Taskvoid

  2. 异步方法中有return语句,则返回值类型为Task<T>,其中T是return语句返回对象的类型。(编译器帮我们把T类型数据转换为Task<T>类型)。所以不要使用return返回一个Task<T>类型的对象,而是只需要返回一个T类型数据即可

  3. 异步方法中没有return语句,但是你需要查看异步方法的状态或是要对Task对象操作(比如task.Wait()),则可定义返回值类型为Task

  4. 异步方法中没有return语句且不需要查看异步方法的状态,则可认为是返回值是void类型。此时称之为“调用并忘记”(fire and forget),其实这并不是一个很好的用法(具体的分析可以看:异步方法的异常处理)!

  5. 若是真的需要返回一个Task<T>类型的数据 (比如在非async修饰的方法中,定义返回值类型就是一个Task<T>类型),则:

    • return Task.Run(()=>{……})

    • T类型转换为Task<T>类型:return Task.FromResult(T data)

    • IAsyncResult类型对象转换为Task类型:return Task.Factory.FromTask(IAsyncResult data)

1.4 其他细节

  1. async修饰符只能用于返回TaskTask<T>viod的方法,或者Lambda表达式中。

  2. async不能用于程序的入口点,即Main()不能使用async修饰符。 谢谢@coredx提醒:C#7.1中应用程序的入口点可以具有async修饰符,参考:What's new in C# 7.1

1.5 async传染性

  1. 简单的说:函数体中含有await表达式的函数,必须使用async 修饰!

    而一个使用了async修饰的方法,在调用它的时候如有必要则必须使用await等待!

    使用了await等待的方法,则其调用方法又必须使用async修饰,这从而形成了一个循环,这就是async传染

    换句话说就是哪里调用了async修饰的方法则async就会传染到哪!

    可以有的时候我们并不想要我们的方法变为async修饰的方法,所以需要避免async传染

    避免的主要方法就是使用延续任务来避免,你想一想之前在Task类中,使用延续任务时,主要就是避免使用await等待!

    参考:C# 5.0中同步执行异步方法

  2. 之前我们说了:主函数Main()不能使用async修饰符,因为Main函数不能够是异步方法,这也就意味着一切的异步方法最终的调用方法一定是同步方法(C#7.1Main可以是异步的),而调用异步方法的那个同步方法,称之为病源隔断方法,因为在这里开始,不再会发生async传染。

1.6 简单示例

示例1:定义一个异步方法,并调用它

static void Main(string[] args)
{
Task<int> t = SumAsync(1, 2);
t.ContinueWith(t => Console.WriteLine( "异步操作结果为:" + t.Result));
for (int i = 0; i < 10; i++)
{
Thread.Sleep(1000);
Console.WriteLine($"循环次数{i}");
}
Console.ReadKey();
} private static async Task<int> SumAsync(int num1, int num2)
{
int sum = await Task.Run(() => { Thread.Sleep(3000); return num1 + num2; });
return sum;
}

示例说明

  1. 异步方法SumAsync()函数体中返回的是整型sum,即返回的是一个整型,但是在声明函数时,返回值需写为:Task<int>

    反过来说:若是异步方法的返回值类型为Task<T>,则在方法中只需要返回T类型的数据

    这一点就是和Task.Run()的返回值的书写方式一样,即若Task.Run()参数是有返回值的委托Func<TResult>,则Task.Run()返回值是Task<TResult>泛型

  2. 异步方法的命名默认是在最后加"Async",即"XXXAsync"。

  3. 调用异步方法的方法称之为调用方法(在这里就是主函数Main()),调用方法和被调用的异步方法,不一定在不同的线程中

  4. 其实你看上面示例的代码也会发现,单独把异步操作封装为一个异步方法,这样可以为异步操作传参!

    你可以还记得的在.net异步程序设计之任务并行库中,多次说明Task.Run()的参数只能是无参委托。

  5. 有一点在这里说明一下:关于异步匿名方法,或是异步Lambda表达式。

    在为一个事件绑定事件处理程序的时候,对于一些简单的事件处理程序,我们可以使用Lambda表达式

    但是我们想要异步操作Lambda表达式,则可以直接写为:

    Butten.Click+=async(sender,e)=>{...await...}

详细可以参照《C#图解教程:20.5使用异步Lambda表达式》



2.异步方法的执行顺序

依旧是上面的示例,我们在每个操作中、操作前、操作后都打印其当前所处的线程,仔细的观察,异步方法的执行顺序。

再次强调,这里用async修饰的方法,称之为异步方法,这里调用该异步方法的方法,称之为调用方法

代码:

//调用方法
static void Main(string[] args)
{
Console.WriteLine($"-1-.正在执行的线程,线程ID:{Thread.CurrentThread.ManagedThreadId,2}------------------调用方法中调用异步方法之前的代码");
Task<int> result = SumAsync(1, 2);
Console.WriteLine($"-3-.正在执行的线程,线程ID:{Thread.CurrentThread.ManagedThreadId,2}------------------调用方法中调用异步方法之后的代码");
result.ContinueWith(t => Console.WriteLine($"-8-.正在执行的线程,线程ID:{Thread.CurrentThread.ManagedThreadId,2}------------------这是延续任务的线程" + "-异步操作结果为:" + result.Result));
Console.WriteLine($"-4-.正在执行的线程,线程ID:{Thread.CurrentThread.ManagedThreadId,2}------------------调用方法中延续任务之后的代码");
for (int i = 0; i < 5; i++)
{
Thread.Sleep(1000);
Console.WriteLine($"正在执行的线程,线程ID:{Thread.CurrentThread.ManagedThreadId,2}"+$"循环次数{i}--------------------------------------调用方法中延续任务之后的代码");
}
Console.ReadKey();
} //异步方法
private static async Task<int> SumAsync(int num1, int num2)
{
Console.WriteLine($"-2-.正在执行的线程,线程ID:{Thread.CurrentThread.ManagedThreadId,2}------------------异步方法中await表达式之前的代码");
int sum1 = await Task.Run(() => { Thread.Sleep(3000); Console.WriteLine($"-5-.正在执行的线程,线程ID:{Thread.CurrentThread.ManagedThreadId,2}------------------这是第一个await表达式的线程"); return num1 + num2; });
Console.WriteLine($"-6-.正在执行的线程,线程ID:{Thread.CurrentThread.ManagedThreadId,2}------------------异步方法中await表达式之后的代码");
int sum2=await Task.Run(() => { Thread.Sleep(3000); Console.WriteLine($"-7-.正在执行的线程,线程ID:{Thread.CurrentThread.ManagedThreadId,2}------------------这是第二个await表达式的线程"); return num1 + num2; });
return sum1+sum2;
}

运行结果:

说明

注意运行顺序:

调用异步方法方法后,按照同步顺序执行异步方法中await表达式之前的代码,

当运行到第1个await表达式后,创建一个新的线程,后台执行该await表达式,实现异步。

第1个await表达式,未完成之前,继续执行调用函数中的异步方法之后的代码(注意await表达式后台未完成之前,不是继续执行await表达式之后的代码,而是继续执行调用函数中的异步方法之后的代码),

当第1个await表达式在后台完成后,继续执行异步方法中第1个await表达式之后的代码,

当运行到第2个await表达式后,创建一个新的线程,后台运行该await表达式,

第2个await表达式,未完成之前,继续执行调用函数中被第1个await完成后打断的的代码

当第2个await表达式在后台运行完成后,继续执行异步方法中第2个await表达式之后的代码,

当异步方法运行到return后,则开始调用方法中的对该异步方法的延续任务

该延续任务和调用方法不在一个线程中,这里有可能和第2个await表达式在同一个线程中,也有可能和第1个await表达式在同一个线程中。



3.取消一个异步操作

具体可参考:.net异步编程值任务并行库-3.6取消异步操作

原理是一样的,都是使用CancellationTokenCancellationTokenSource两个类实现取消异步操作

看一个简单的示例:

        static void Main(string[] args)
{
CancellationTokenSource cts = new CancellationTokenSource();//生成一个CancellationTokenSource对象,
CancellationToken ct = cts.Token;//该对象可以创建CancellationToken对象,即一个令牌(token)
Task result = DoAsync(ct, 50);
for (int i = 0; i <= 5; i++)//主线程中的循环(模拟在异步方法声明之后的工作)
{
Thread.Sleep(1000);
Console.WriteLine("主线程中的循环次数:" + i);
}
cts.Cancel();//注意在主线程中的循环结束后(5s左右),运行到此处,
//则此时CancellationTokenSource对象中的token.IsCancellationRequested==true
//则在异步操作DoAsync()中根据此判断,则取消异步操作
Console.ReadKey();
CancellTask(); CancellTask2();
} //异步方法:取消异步操作的令牌通过参数传入
static async Task DoAsync(CancellationToken ct, int Max)
{
await Task.Run(() =>
{
for (int i = 0; i <= Max; i++)
{
if (ct.IsCancellationRequested)//一旦CancellationToken对象的源CancellationTokenSource运行了Cancel();此时CancellationToken.IsCancellationRequested==ture
{
return;
}
Thread.Sleep(1000);
Console.WriteLine("次线程中的循环次数:" + i);
}
}/*,ct*/);//这里取消令牌可以作为Task.Run()的第二个参数,也可以不写!
}



4.同步和异步等待任务

4.1 在调用方法中同步等待任务

“调用方法可以调用任意多个异步方法并接收它们返回的Task对象。然后你的代码会继续执行其他任务,但在某个点上可能会需要等待某个特殊Task对象完成,然后再继续。为此,Task类提供了一个实例方法wait,可以在Task对象上调用该方法。”--《C#图解教程》

使用task.Wait();等待异步任务task完成:

Wait方法用于单一Task的对象。若是想要等待多个Task,可以使用Task类中的两个静态方法,其中WaitAll等待所有任务都结束,WaitAny等待任一任务结束。

示例:使用Task.WaitAll()和Task.WaitAny()

static void Main(string[] args)
{
Console.WriteLine($"当前线程ID:{Thread.CurrentThread.ManagedThreadId,2 }:Task之前...");
Task<int> t1 = DoAsync(2000);
Task<int> t2 = DoAsync(6000); //Task.WaitAll(t1, t2);//等待t1和t2都完毕后才进行后续的代码(即阻塞了主线程)
//Task.WaitAny(t1, t2);//等待t1和t2中有任一个完成(调试的时候,你就会发现当t1完成后就开始执行后续的循代码) for (int i = 0; i < 10; i++)
{
Thread.Sleep(1000);
Console.WriteLine($"当前线程ID:{Thread.CurrentThread.ManagedThreadId,2}:循环中");
}
Console.ReadKey();
} private static async Task<int> DoAsync(int num)
{
int result = await Task.Run(() => { Thread.Sleep(num); Console.WriteLine($"当前线程ID{Thread.CurrentThread.ManagedThreadId,2}:异步操作之等待:{num}s"); return num; });
return result;
}

说明1 :

对代码中注释掉的代码分别调试,则可以发现其中的不同。

Task.WaitAll(params Task[] tasks):表示停止当前主线程,等待Task类型数组tasks中的所有Task操作结束,即会发生阻塞

Task.WaitAll()调试结果:

说明2:

Task.WaitAny(params Task[] tasks):表示停止当前主线程,等待Task类型数组tasks中的任一个Task操作结束,也是会发生阻塞,单是阻塞主线程在任一个Task操作结束,之后主线程会继续,其他的Task在后台继续

Task.WaitAny()调试结果:

4.2 在调用方法中异步等待任务

4.2.1使用await等待异步任务

其实在一个方法中调用多个异步方法时候,当某个异步方法依赖于另外一个异步方法的结果的时候,我们一般是在每一个调用的异步方法处使用await关键字等待该异步操作的结果,但是这样就会出现async传染。

await不同于Wait(),await等待是异步的,不会阻塞线程,而Wait()会阻塞线程

注意如无必用,或是不存在对某个异步操作的等待,尽量不要使用await,直接把异步操作的返回值给Task<T>类型的变量,可以使程序运行的更快!

其实你也注意到了:不使用await等待异步操作,则异步操作的返回值就是定义的返回值Task<T>,但是使用await等待则异步操作的返回值就是具体的简单类型,比如int类型等。

换言之:异步方法的返回值是Task<T>,则使用await等待可以直接获取异步方法的T类型的返回值

示例:

static void Main(string[] args)
{
ReferencingMethodAsync();
} //该调用函数也要使用async关键字修饰(即async传染),因为使用了await等待,
private static async void ReferencingMethodAsync()
{
int result1 = await SumAsync(1, 2);//这里使用了await 关键字则,调用方法MultipleMethod2()必须使用async修饰(即async传染性)
int result2 = await SumAsync(1, result1);
Console.WriteLine(result2);
} private static async Task<int> SumAsync(int num1, int num2)
{
int sum = await Task.Run(() => { Thread.Sleep(3000); return num1 + num2; });
return sum;
}

4.2.2使用WhenAll()和WhenAny()

Task.WhenAll()Task.WhenAny()Task.WaitAll()Task.WaitAny()的异步版本,即异步等待Task完成

示例:使用Task.WhenAll()和Task.WhenAny()

static void Main(string[] args)
{
Console.WriteLine($"当前线程ID:{Thread.CurrentThread.ManagedThreadId,2 }:Task之前...");
Task<int> t1 = DoAsync(2000);
Task<int> t2 = DoAsync(6000);
//Task.WhenAll(t1, t2);//异步等待t1和t2两个完成(调试的时候你会发现任务t1和t2都在新的线程中执行,主线继续执行后续的循环代码)
//Task.WhenAny(t1, t2);//异步等待t1和t2中任一个完成(调试的时候你就会发现两个任务分别在新线程中执行,线程继续执行后续的循环代码,当t1完成后,继续后续的循环代码) for (int i = 0; i < 10; i++)
{
Thread.Sleep(1000);
Console.WriteLine($"当前线程ID:{Thread.CurrentThread.ManagedThreadId,2}:循环中");
}
Console.ReadKey();
} private static async Task<int> DoAsync(int num)
{
int result = await Task.Run(() => { Thread.Sleep(num); Console.WriteLine($"当前线程ID{Thread.CurrentThread.ManagedThreadId,2}:异步操作之等待:{num}s"); return num; });
return result;
}

说明1

在示例中看到Task.WhenAll和Task.WhenAny的使用,但是在实际中有什么作用呢?

首先,如前所所述,Task.WhenAll()和Task.WhenAny()是Task.WaitAll()和Task.WaitAny()的异步版本,但是呢,Task.WaitAll()和Task.WaitAny()是没有返回值的,Task.WhenAll()Task.WhenAny()是有返回值,返回值类型是一个Task对象,所以你可以给其一个延续任务,即在异步等待的Task完成后,指定继续执行的Task。

所以当调用的异步方法没有相互的依赖的时候,一般还是使用WhenAll(),来等待异步方法,同时也可以给所有的异步方法结束后添加一个延续任务!

示例:为异步等待后添加延续工作


static void Main(string[] args)
{
Console.WriteLine($"当前线程ID:{Thread.CurrentThread.ManagedThreadId,2 }:Task之前...");
Task<int> t1 = DoAsync(2000);
Task<int> t2 = DoAsync(6000); //Task.WhenAll(t1, t2).ContinueWith(t => Console.WriteLine($"当前线程ID:{Thread.CurrentThread.ManagedThreadId,2 }:延续任务,两个异步操作返回值是一个int[],其中元素分别是{t.Result[0]}、{t.Result[1]}")); //Task.WhenAny(t1, t2).ContinueWith(t => Console.WriteLine($"当前线程ID:{Thread.CurrentThread.ManagedThreadId,2 }:延续任务,第一个完成的异步操作返回值是{t.Result.Result}")); for (int i = 0; i < 8; i++)
{
Thread.Sleep(1000);
Console.WriteLine($"当前线程ID:{Thread.CurrentThread.ManagedThreadId,2}:循环中");
}
Console.ReadKey();
} private static async Task<int> DoAsync(int num)
{
int result = await Task.Run(() => { Thread.Sleep(num); Console.WriteLine($"当前线程ID:{Thread.CurrentThread.ManagedThreadId,2}:异步操作之等待:{num}s"); return num; });
return result;
}

说明1

若是Task.WhenAll()后的延续工作,则注意Task.WhenAll()的返回的Task<TResult>ResultTResult[]类型

即多个Task的返回值,存放在一个数组中

运行结果:

说明2:

若是Task.WhenAny()后的延续工作,则注意Task.WhenAny()的返回的是Task<Task>类型,即其ResultTask<TResutl>类型,所以为了获取第一结束的Task的返回值,需要:t.Result.Result

运行结果:

说明3

Task.WhenAll(Task[] tasks).ContinueWith(Action<Task>)

等价于Task.Factory.ContinueWhenAll(Task[] tasks, Action<Tast>)

Task.WhenAny(Task[] tasks).ContinueWith(Action<Task>)

等价于Task.Factory.ContinueWhenAny(Task[] tasks, Action<Tast>)



5.异步操作中的异常处理

5.1 异常处理

一般程序中对异常的处理使用try{……} catch{……}

首先看一个捕获异常失败的示例:

在Main()中调用ThrowEx(2000,"这是异常信息"),第一个参数是ThrowEx中的Tast延迟的时间,第二个参数是ThrowEx中的抛出异常的信息。

static void Main(string[] args)
{
try
{
ThrowEx(2000, "这是异常信息");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadKey();
}
private async static Task ThrowEx(int ms, string message)//注意这里的返回值类型为Task,若是写成void也是无法在catch语句中捕获异常,但是运行vs会报错(见:说明2)
{
await Task.Delay(ms).ContinueWith(t => Console.WriteLine("hello word"));
throw new Exception(message);
}

说明1:

多打断点,就可以发现为何捕捉不到异常了。

因为当调用ThrowEx(2000, "异常信息"),开始异步方法中的await表达式,

即创建一个新的线程,在后台执行await表达式,而主线程中此时会继续执行ThrowEx(2000, "异常信息"); 后的代码:catch (Exception ex)

此时,异步方法中还在等待await表达式的执行,还没有抛出我们自己定义的异常,所以此时压根就没有异常抛出,所以catch语句也就捕获不到异常,

而当异步方法抛出异常,此时主线程中catch语句已经执行完毕了!

说明2:

1.基本语法-返回值类型中我们说道:在编写异步方法的时候,有时后没有返回值,也不需要查看异步操作的状态,我们设置返回值类型为void,而且称之为“调用并忘记”。然而这种异步代码编写方式,并不值得提倡。

为什么呢?若是没有返回值,异步方法中抛出的异常就无法传递到主线程,在主线程中的catch语句就无法捕获拍异常!所以异步方法最好返回一个Task类型

异步方法有返回值的时候,抛出的在异常会置于Task对象中,可以通过task.IsFlauted属性查看是否有异常,在主线程的调用方法中,使用catch语句可以捕获异常!


正确示例:只需要给调用的异步方法,添加一个await

static void Main(string[] args)
{
try
{
await ThrowEx(2000, "这是异常信息");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadKey();
}
private async static Task ThrowEx(int ms, string message)
{
await Task.Delay(ms).ContinueWith(t => Console.WriteLine("hello word"));
throw new Exception(message);
}

5.2 多个异步方法的异常处理

使用Task.WhenAll()处理多个异步方法中抛出异常

当有多个异步操作,使用WhenAll异步等待,其返回值是一个Task类型对象,该对象的异常为AggregateException类型的异常,每一个的子任务(即WhenAll所等待的所有任务)抛出的异常都是包装在这一个AggregateException中,若是需要打印其中的异常,则需要遍历AggregateException.InnerExceptions

static void Main(string[] args)
{
Task taskResult = null;//注意因为在catch语句中需要使用这个WhenAll的返回值,所以定义在try语句之外。
try
{
Console.WriteLine($"当前的线程Id:{Thread.CurrentThread.ManagedThreadId,2}:do something before task");
Task t1 = ThrowEx($"这是第一个抛出的异常信息:异常所在线程ID:{Thread.CurrentThread.ManagedThreadId,2}", 3000);
Task t2 = ThrowEx($"这是第二个抛出的异常信息:异常所在线程ID:{Thread.CurrentThread.ManagedThreadId,2}", 5000); await (taskResult = Task.WhenAll(t1, t2));
}
catch (Exception)//注意这里捕获的异常只是WhenAll()等待的异步任务中第一抛出的异常
{
foreach (var item in taskResult.Exception.InnerExceptions)//通过WhenAll()的返回对象的Exception属性来查阅所有的异常信息
{
Console.WriteLine($"当前的线程Id:{Thread.CurrentThread.ManagedThreadId,2}:{item.Message}");
}
}
} private async static Task ThrowEx(int ms, string message)
{
await Task.Delay(ms).ContinueWith(t => Console.WriteLine("hello word"));
throw new Exception(message);
}

运行结果:

说明

Task.WhenAll()返回的Task对象中的Exception属性是AggregateException类型的异常.

注意,该访问该异常InnerExcption属性则只包含第一个异常,该异常的InnerExcptions属性,则包含所有子任务异常.

5.3 AggregateException中的方法

首先多个异步操作的异常会包装在一个AggregateException异常中,被包装的异常可以也是AggregateException类型的异常,所以若是需要打印异常信息可能需要循环嵌套,比较麻烦。

故可以使用 AggregateException.Flatten()打破异常的嵌套。

注意,凡是使用await等待的异步操作,它抛出的异常无法使用catch(AggregateException)捕获!

只能使用catch (Exception)对异常捕获,在通过使用Task的返回值的Exception属性对异性进行操作。

当然你要是想使用catch(AggregateException)捕获到异常,则可以使用task.Wait()方法等待异步任务,则抛出的异常为AggregateException类型的异常

示例:(完整Demo

catch (AggregateException ae)//AggregateException类型异常的错误信息是“发生一个或多个异常”
{
foreach (var exception in ae.Flatten().InnerExceptions)
//使用AggregateException的Flatten()方法,除去异常的嵌套,这里你也可以测试不使用Flatten(),抛出的信息为“有一个或多个异常”
{
if (exception is TestException)
{
Console.WriteLine(exception.Message);
}
else
{
throw;
}
}
}

若是需要针对AggregateException中某个或是某种异常进行处理,可以使用Handle()方法

Handel()的参数是一个有返回值的委托:Func<Exception,bool> predicate

示例:(完整Demo

catch (Exception)
{
t.Exception.Handle(e =>
{
if (e is TestException)//如果是TestException类型的异常
{
Console.WriteLine(e.Message);
}
return e is TestException;
});
}



6.多线程和异步的区分

不要把多线程异步两个概念混为一谈!异步是最终目的,多线程只是我们实现异步的一种手段!

首先,使用异步和多线程都可以避免线程的阻塞,但是原理是不一样的。

多线程:当前线程中创建一个新的线程,当前线程线程则不会被锁定了,但是锁定新的线程执行某个操作。换句话说就是换一条线程用来代替原本会被锁定的主线程!优点就是,线程中的处理程序的运行顺序还是从上往下的,方便理解,但是线程间的共享变量可能造成死锁的出现。

异步:异步概念是与同步的概念相对的,简单的说就是:调用者发送一个调用请求后,调用者不需要等待被被调用者返回结果而可以继续做其他的事情。实现异步一般是通过多线程,但是还可以通过多进程实现异步!

多线程和异步可以解决不同的问题

但是首先我们要区分当前需要长时间操作的任务是:CPU密集型还是IO密集型,具体可参考长时间的复杂任务又分为两种

CPU Bound:使用多线程

IO Bound:使用异步



7. 在 .NET MVC中异步编程

现在的 ASP .NET MVC项目中,若使用的.net中的方法有异步版本的就尽量使用异步的方法。

在MVC项目中异步编程可以大大的提高网站服务器的吞吐量,即可以可以大大的提高网站的同时受理的请求数量

据传,MVC网站若是异步编程则可以提高网站的同时访问量的2.6倍。

注意是提高网站的同时访问量,而不是提高网站的访问速度!

在MVC项目异步编程的的方式和在控制台中一样,使用async和await,基于任务的异步编程模式

简单的示例:同步和异步两种方式分别读取桌面1.txt文件

//同步操作
public ActionResult Index()
{
string msg = "";
using (StreamReader sr = new StreamReader(@"C:\Users\shanzm\Desktop\1.txt", Encoding.Default))
{
while (!sr.EndOfStream)
{
msg = sr.ReadToEnd();
}
}
return Content(msg);
} //异步操作
public async Task<ActionResult> Index2()
{
string msg = "";
using (StreamReader sr = new StreamReader(@"C:\Users\shanzm\Desktop\1.txt", Encoding.Default))
{
while (!sr.EndOfStream)
{
msg = await sr.ReadToEndAsync();//使用异步版本的方法
}
}
return Content(msg);
}



8. 参考及示例源码

源码:点击下载

书籍:C#高级编程

书籍:精通C#

微软:基于任务的异步编程

微软:异常处理(任务并行库)

.NET异步程序设计之async&await的更多相关文章

  1. ASP.NET 异步编程之Async await

    本文重点介绍的是.NET Framework4.5 推出的异步编程方案  async await 请先看个5分钟的微软演示的视频:视频地址: https://channel9.msdn.com/Blo ...

  2. 异步Promise及Async/Await可能最完整入门攻略

    此文只介绍Async/Await与Promise基础知识与实际用到注意的问题,将通过很多代码实例进行说明,两个实例代码是setDelay和setDelaySecond. tips:本文系原创转自我的博 ...

  3. C# 同步 异步 回调 状态机 async await Demo

    源码 https://gitee.com/s0611163/AsyncAwaitDemo 为什么会研究这个? 我们项目的客户端和服务端通信用的是WCF,我就想,能不能用异步的方式调用WCF服务呢?或者 ...

  4. 异步编程(async&await)

    前言 本来这篇文章上个月就该发布了,但是因为忙 QuarkDoc 一直没有时间整理,所以耽搁到今天,现在回归正轨. C# 5.0 虽然只引入了2个新关键词:async和await.然而它大大简化了异步 ...

  5. 学习迭代器实现C#异步编程——仿async/await(一)

    .NET 4.5的async/await真是个神奇的东西,巧妙异常以致我不禁对其实现充满好奇,但一直难以窥探其门径.不意间读了此篇强文<Asynchronous Programming in C ...

  6. 异步编程之Async,Await和ConfigureAwait的关系

    在.NET Framework 4.5中,async / await关键字已添加到该版本中,简化多线程操作,以使异步编程更易于使用.为了最大化利用资源而不挂起UI,你应该尽可能地尝试使用异步编程.虽然 ...

  7. 异步Promise及Async/Await最完整入门攻略

    一.为什么有Async/Await? 我们都知道已经有了Promise的解决方案了,为什么还要ES7提出新的Async/Await标准呢? 答案其实也显而易见:Promise虽然跳出了异步嵌套的怪圈, ...

  8. C# 异步编程(async&await)

    同步:同步就是指一个进程在执行某个请求的时候,若该请求需要一段时间才能返回信息,那么这个进程将会一直等待下去,直到收到返回信息才继续执行下去 异步:异步是指进程不需要一直等下去,而是继续执行下面的操作 ...

  9. C#多线程和异步——Task和async/await详解

    阅读目录 一.什么是异步 二.Task介绍 1 Task创建和运行 2 Task的阻塞方法(Wait/WaitAll/WaitAny) 3 Task的延续操作(WhenAny/WhenAll/Cont ...

随机推荐

  1. 吴裕雄--天生自然python学习笔记:python 建立 Firebase 数据库连接

    Python 程序通过 python-firebase 包可以存取 Firebase 数据库. 使用 python-firebase 包 首先必须安装 python-firebase 包,安装方法如下 ...

  2. 主效应|处理误差 |组间误差|处理效应|随机误差|组内误差|误差|效应分析|方差齐性检验|SSE|SSA|SST|MSE|MSA|F检验|关系系数|完全随机化设计|区组设计|析因分析

    8 什么是只考虑主效应的方差分析? 就是不考虑交互效应的方差分析,即认为因素之间是不相互影响的,就是无重复的方差分析.   什么是处理误差 (treatment error).组间误差(between ...

  3. appium自动化的工作原理(1)

    用appium开发移动端自动化测试脚本这么长时间,还没有认证的了解下它的原理是什么,到底是如何实现的呢? 1.先看一个Appium加载的过程图解(来自:了解appium自动化的工作原理--https: ...

  4. Outlook邮件的右键菜单中添加自定义按钮

    customUI代码如下: <customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui"> ...

  5. python、anaconda、jupyter notebook、pycharm、spyder

    说明: 1.anaconda把任何东西都当做包来管理. 2.anaconda本省集成了python和conda.spyder.numpy等. 3.pip只用于python,conda可用于多种语言. ...

  6. HOG算法基础

    实现思路步骤: 1.对原图像gamma校正,img=sqrt(img); 2.求图像竖直边缘,水平边缘,边缘强度,边缘斜率. 3.将图像每16*16(取其他也可以)个像素分到一个cell中.对于256 ...

  7. list split批量处理

    <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-colle ...

  8. leetcode第32题:最长有效括号

    关于括号匹配或生成的问题,首先想到的是栈. 本题易错点:返回值为连续有效()的长度, 即()(()这种情况下,返回值为2 # 去除字符串首的连续)和字符串尾得连续( while True: if no ...

  9. Java完成生产者消费者模型

    生产者和消费者模型,是多线程中的典型模型,这里使用Java完成该模型 ServerTest.java 生产者代码 package com.orange.threadmodel; import java ...

  10. spring 任务调度quartz

    简单记录一下spring任务调度quartz的例子 首先添加包 quartz-2.2.3.jar 然后写个简单的TestJob类 package com.job; import java.util.D ...