前言
最近在学习Web Api框架的时候接触到了async/await，这个特性是.NET 4.5引入的，因为以前对于异步编程不是很了解，因此花费了一些时间学习一下相关的知识，并整理成这篇博客，若是在阅读的过程当中发现不对的地方，欢迎你们指正。python
同步编程与异步编程
一般状况下，咱们写的C#代码就是同步的，运行在同一个线程中，从程序的第一行代码到最后一句代码顺序执行。而异步编程的核心是使用多线程，经过让不一样的线程执行不一样的任务，实现不一样代码的并行运行。正则表达式
前台线程与后台线程
关于多线程，早在.NET2.0时代，基础类库中就提供了Thread实现。默认状况下，实例化一个Thread建立的是前台线程，只要有前台线程在运行，应用程序的进程就一直处于运行状态，以控制台应用程序为例，在Main方法中实例化一个Thread，这个Main方法就会等待Thread线程执行完毕才退出。而对于后台线程，应用程序将不考虑其是否执行完毕，只要应用程序的主线程和前台线程执行完毕就能够退出，退出后全部的后台线程将被自动终止。来看代码应该更清楚一些：编程
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Threading;
using
System.Threading.Tasks;
namespace
ConsoleApp
{
class
Program
{
static
void
Main(
string
[] args)
{
Console.WriteLine(
"主线程开始"
);
//实例化Thread，默认建立前台线程
Thread t1 =
new
Thread(DoRun1);
t1.Start();
//能够经过修改Thread的IsBackground，将其变为后台线程
Thread t2 =
new
Thread(DoRun2) { IsBackground =
true
};
t2.Start();
Console.WriteLine(
"主线程结束"
);
}
static
void
DoRun1()
{
Thread.Sleep(500);
Console.WriteLine(
"这是前台线程调用"
);
}
static
void
DoRun2()
{
Thread.Sleep(1500);
Console.WriteLine(
"这是后台线程调用"
);
}
}
}
|
运行上面的代码，能够看到DoRun2方法的打印信息“这是后台线程调用”将不会被显示出来，由于应用程序执行完主线程和前台线程后，就自动退出了，全部的后台线程将被自动终止。这里后台线程设置了等待1.5s，假如这个后台线程比前台线程或主线程提早执行完毕，对应的信息“这是后台线程调用”将能够被成功打印出来。多线程
Task
.NET 4.0推出了新一代的多线程模型Task。async/await特性是与Task紧密相关的，因此在了解async/await前必须充分了解Task的使用。这里将以一个简单的Demo来看一下Task的使用，同时与Thread的建立方式作一下对比。框架
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Web;
using
System.Threading;
using
System.Threading.Tasks;
namespace
TestApp
{
class
Program
{
static
void
Main(
string
[] args)
{
Console.WriteLine(
"主线程启动"
);
//.NET 4.5引入了Task.Run静态方法来启动一个线程
Task.Run(() => { Thread.Sleep(1000); Console.WriteLine(
"Task1启动"
); });
//Task启动的是后台线程，假如要在主线程中等待后台线程执行完毕，能够调用Wait方法
Task task = Task.Run(() => { Thread.Sleep(500); Console.WriteLine(
"Task2启动"
); });
task.Wait();
Console.WriteLine(
"主线程结束"
);
}
}
}
Task的使用
|
首先，必须明确一点是Task启动的线程是后台线程，不过能够经过在Main方法中调用task.Wait()方法，使应用程序等待task执行完毕。Task与Thread的一个重要区分点是：Task底层是使用线程池的，而Thread每次实例化都会建立一个新的线程。这里能够经过这段代码作一次验证：异步
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Web;
using
System.Threading;
using
System.Threading.Tasks;
namespace
TestApp
{
class
Program
{
static
void
DoRun1()
{
Console.WriteLine(
"Thread Id ="
+ Thread.CurrentThread.ManagedThreadId);
}
static
void
DoRun2()
{
Thread.Sleep(50);
Console.WriteLine(
"Task调用Thread Id ="
+ Thread.CurrentThread.ManagedThreadId);
}
static
void
Main(
string
[] args)
{
for
(
int
i = 0; i < 50; i++)
{
new
Thread(DoRun1).Start();
}
for
(
int
i = 0; i < 50; i++)
{
Task.Run(() => { DoRun2(); });
}
//让应用程序不当即退出
Console.Read();
}
}
}
Task底层使用线程池
|
运行代码，能够看到DoRun1()方法每次的Thread Id都是不一样的，而DoRun2()方法的Thread Id是重复出现的。咱们知道线程的建立和销毁是一个开销比较大的操做，Task.Run()每次执行将不会当即建立一个新线程，而是到CLR线程池查看是否有空闲的线程，有的话就取一个线程处理这个请求，处理完请求后再把线程放回线程池，这个线程也不会当即撤销，而是设置为空闲状态，可供线程池再次调度，从而减小开销。async
Task<TResult>
Task<TResult>是Task的泛型版本，这两个之间的最大不一样是Task<TResult>能够有一个返回值，看一下代码应该一目了然：ide
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Web;
using
System.Threading;
using
System.Threading.Tasks;
namespace
TestApp
{
class
Program
{
static
void
Main(
string
[] args)
{
Console.WriteLine(
"主线程开始"
);
Task<
string
> task = Task<
string
>.Run(() => { Thread.Sleep(1000);
return
Thread.CurrentThread.ManagedThreadId.ToString(); });
Console.WriteLine(task.Result);
Console.WriteLine(
"主线程结束"
);
}
}
}
Task<TResult>的使用
|
Task<TResult>的实例对象有一个Result属性，当在Main方法中调用task.Result的时候，将等待task执行完毕并获得返回值，这里的效果跟调用task.Wait()是同样的，只是多了一个返回值。异步编程
async/await 特性
通过前面的铺垫，终于迎来了这篇文章的主角async/await，仍是先经过代码来感觉一下这两个特性的使用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Web;
using
System.Threading;
using
System.Threading.Tasks;
namespace
TestApp
{
class
Program
{
static
void
Main(
string
[] args)
{
Console.WriteLine(
"-------主线程启动-------"
);
Task<
int
> task = GetLengthAsync();
Console.WriteLine(
"Main方法作其余事情"
);
Console.WriteLine(
"Task返回的值"
+ task.Result);
Console.WriteLine(
"-------主线程结束-------"
);
}
static
async Task<
int
> GetLengthAsync()
{
Console.WriteLine(
"GetLengthAsync Start"
);
string
str = await GetStringAsync();
Console.WriteLine(
"GetLengthAsync End"
);
return
str.Length;
}
static
Task<
string
> GetStringAsync()
{
return
Task<
string
>.Run(() => { Thread.Sleep(2000);
return
"finished"
; });
}
}
}
async/await 用法
|
首先来看一下async关键字。async用来修饰方法，代表这个方法是异步的，声明的方法的返回类型必须为：void或Task或Task<TResult>。返回类型为Task的异步方法中无需使用return返回值，而返回类型为Task<TResult>的异步方法中必须使用return返回一个TResult的值，如上述Demo中的异步方法返回一个int。
再来看一下await关键字。await必须用来修饰Task或Task<TResult>，并且只能出如今已经用async关键字修饰的异步方法中。
一般状况下，async/await必须成对出现才有意义，假如一个方法声明为async，但却没有使用await关键字，则这个方法在执行的时候就被看成同步方法，这时编译器也会抛出警告提示async修饰的方法中没有使用await，将被做为同步方法使用。了解了关键字async\await的特色后，咱们来看一下上述Demo在控制台会输入什么吧。
输出的结果已经很明确地告诉咱们整个执行流程了。GetLengthAsync异步方法刚开始是同步执行的，因此”GetLengthAsync Start”字符串会被打印出来，直到遇到第一个await关键字，真正的异步任务GetStringAsync开始执行，await至关于起到一个标记/唤醒点的做用，同时将控制权放回给Main方法，”Main方法作其余事情”字符串会被打印出来。以后因为Main方法须要访问到task.Result，因此就会等待异步方法GetLengthAsync的执行，而GetLengthAsync又等待GetStringAsync的执行，一旦GetStringAsync执行完毕，就会回到await GetStringAsync这个点上执行往下执行，这时”GetLengthAsync End”字符串就会被打印出来。
固然，咱们也可使用下面的方法完成上面控制台的输出。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Web;
using
System.Threading;
using
System.Threading.Tasks;
namespace
TestApp
{
class
Program
{
static
void
Main(
string
[] args)
{
Console.WriteLine(
"-------主线程启动-------"
);
Task<
int
> task = GetLengthAsync();
Console.WriteLine(
"Main方法作其余事情"
);
Console.WriteLine(
"Task返回的值"
+ task.Result);
Console.WriteLine(
"-------主线程结束-------"
);
}
static
Task<
int
> GetLengthAsync()
{
Console.WriteLine(
"GetLengthAsync Start"
);
Task<
int
> task = Task<
int
>.Run(() => {
string
str = GetStringAsync().Result;
Console.WriteLine(
"GetLengthAsync End"
);
return
str.Length; });
return
task;
}
static
Task<
string
> GetStringAsync()
{
return
Task<
string
>.Run(() => { Thread.Sleep(2000);
return
"finished"
; });
}
}
}
不使用async\await
|
对比两种方法，是否是async\await关键字的原理其实就是经过使用一个线程完成异步调用吗？答案是否认的。async关键字代表能够在方法内部使用await关键字，方法在执行到await前都是同步执行的，运行到await处就会挂起，并返回到Main方法中，直到await标记的Task执行完毕，才唤醒回到await点上，继续向下执行。更深刻点的介绍能够查看文章末尾的参考文献。
async/await 实际应用
微软已经对一些基础类库的方法提供了异步实现，接下来将实现一个例子来介绍一下async/await的实际应用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Web;
using
System.Threading;
using
System.Threading.Tasks;
using
System.Net;
namespace
TestApp
{
class
Program
{
static
void
Main(
string
[] args)
{
Console.WriteLine(
"开始获取博客园首页字符数量"
);
Task<
int
> task1 = CountCharsAsync(
"http://www.cnblogs.com"
);
Console.WriteLine(
"开始获取百度首页字符数量"
);
Task<
int
> task2 = CountCharsAsync(
"http://www.baidu.com"
);
Console.WriteLine(
"Main方法中作其余事情"
);
Console.WriteLine(
"博客园:"
+ task1.Result);
Console.WriteLine(
"百度:"
+ task2.Result);
}
static
async Task<
int
> CountCharsAsync(
string
url)
{
WebClient wc =
new
WebClient();
string
result = await wc.DownloadStringTaskAsync(
new
Uri(url));
return
result.Length;
}
}
}
Demo
|
参考文献：<IIIustrated C# 2012> 关于async/await的FAQ