发布于 

C#：异步编程中的 async 和 await

async 和 await 在 C# 5.0 就已经引入了，用来处理异步编程，但之前用的相对较少，现在在 dotNet Core 时代，已经使用的非常普遍，很多的开源组件中提供了大量的后缀为 Async （异步）的方法。本文就简单讲讲 async 和 await。

同步和异步概念

异步是相对于同步来说的，同步是指多个方法顺序执行，后一个会等待前一个执行完成后，才开始执行；异步是指调用一个方法 A ，调用后会立即返回（不用等方法 A 执行完成），接着调用后面的方法 B，举个例子：

  • 同步：你需要还原数据库来调试一个问题，还原数据库需要十分钟，还原的过程中你一直等着，等数据源还原完成后，写代码连接数据库进行代码调试；
  • 异步：数据库开始还原时，你可以去分析代码，中间间隔一段时间检查数据库是否还原完成，如果完成，写代码进行调试。

异步解决的问题

  • 在 Winform 等富客户端程序中可以让 UI 线程避免阻塞；
  • 高效处理 IO 密集型任务和 CPU 密集型任务；
  • 处理执行时间比较长的操作（比如：文件转换等）。

实现异步的一些方式

  • 在 .NET 2.0 时代使用 BeginInvoke、EndInvoke 和回调的方式实现；
  • 将一些耗时的操作写成同步的方法，然后起一个新的线程或 Task 进行调用；
  • 使用 async 和 await 的异步编程模型；
  • 使用消息队列。

Task

在 Task 出来之前，使用的比较多的就是多线程，最经典的问题就是在 Winform 程序中为了能让界面中显示进度之类的动态内容时，需要创建一个新的线程来做，这样主 UI 线程才不会被堵塞卡死，例如下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private void btnTest_Click(object sender, EventArgs e)
{
    Thread thread = new Thread(new ThreadStart(DoWork));
    thread.Start();
}
private void DoWork()
{
    for (int i = 0; i < 100; i++)
    {
        Thread.Sleep(100);
        this.Invoke(new Action<string>(this.ChangeLabel),i.ToString());
    }
}
private void ChangeLabel(string i)
{c
    label1.Text = i + "/100";
}

上面代码中的 DoWork 方法的 Thread.Sleep(100)， 真实情况可能是一个耗时操作，那么这个线程会处于阻塞状态，直到结果返回，会影响性能和造成资源浪费。

在 C# 5 中引入了 Task，一个任务对象，用来实现异步编程，Task 是基于线程池，线程池避免了启动和终止线程的开销，也避免了创建太多的线程，防止系统将大量的时间耗费在线程的切换上。主线程结束后，所有的 Task 任务也将结束。下面是使用 Task 实现和上面相同的功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
private void btnTest_Click(object sender, EventArgs e)
{
    Task.Run(() =>
    {
        for (int i = 0; i < 1000; i++)
        {
            this.Invoke(new Action(() => {
                label1.Text = i.ToString();
            }));
            Thread.Sleep(10);
        }
    });
}

通常我们会使用 Task.Run 来开始执行一个任务，在 Run 方法中传入一个委托，可以是 Action 或者 Func、一旦 Run 方法调用，委托代码会立即执行。

当有多个 Task 任务的时候，可以使用 Task.WaitAll 或 Task.WaitAny 等待一个或多个任务的完成，才让主线程继续。下面例子使用 WatiAll 进行等待：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
static void Main(string[] args)
{
    Console.WriteLine("start"); 
    Task task1= Task.Run(() =>
    {
        Thread.Sleep(2000); 
        Console.WriteLine("task1");
    });
    Task task2=Task.Run(() =>
    {
        Thread.Sleep(3000); 
        Console.WriteLine("task2");
    });
    Task.WaitAll(task1,task2);
    Console.WriteLine($"task1 task2已经执行完成");
    Task task3=Task.Run(() =>
    {
        Thread.Sleep(5000); 
        Console.WriteLine("task3");
    });
    
    Console.WriteLine("end"); 
    Console.ReadLine();
}

执行结果如下：

当把上面代码中的 WaitAll 换成 WaitAny ,可以看出当 task1 执行完成后等待就结束了，调用结果如下：

async 和 await

async 和 await 是 C# 的语法糖，用来简化异步编程模型，首先来看下 async 和 await 的代码结构。

结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("start");
        Test1Async();
        Console.WriteLine("end");

        Console.ReadLine();
    }
    static async void Test1Async()
    {
        await Task.Delay(3000);
        Console.WriteLine("Test1");
    }
}
  • 方法以 Async 结尾，这是一种约束，并不强制要求，但通常会这么做；
  • 方法添加 async 标识符，对于 async 标识符有下面几点需要说明：
    • async 只是表明这个方法中可能有异步调用，并不能表示这个方法就是异步方法；
    • async 是一个专门给编译器的提示，意思是该函数的实现可能会出现await；
    • async 唯一的用处是给await提供上下文，做向下兼容的；
    • 如果函数被标记为 async，函数体内部的 await 才会被解释成关键字，而不会当成是一个函数，所以说当方法中有使用 await 关键字调用异步方法，所在的方法必须使用 async；
    • async不是函数声明的一部分，仅仅是一个标识符，从调用者的角度来看，不存在async。
  • 在方法的内部使用 await 关键字，只要是返回 Task 对象的方法就可以使用 await，如果没有 await，那么有 async 标识符的方法就相当于是一个同步方法。

上面的代码中在 Task.Delay(3000); 前面添加了 await 关键字，会发现最后的执行结果为：

说明添加 await 关键字之后会进行等待，就让会等待，就变成和同步一样了吗？答案当然不是：

  • 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
    static async Task Main(string[] args)
    {
        Stopwatch watch  =Stopwatch.StartNew();
        Console.WriteLine("start"); 
        Task<string> task1= Test1Async();
        Task<string> task2= Test2Async();
        Console.WriteLine("end");
        
        Console.WriteLine($"{task1.Result},{task2.Result}");
        watch.Stop();
        Console.WriteLine($"运行时间：{watch.ElapsedMilliseconds/1000} 秒");

        Console.ReadLine();
    }
    static async Task<string> Test1Async()
    {
        await Task.Delay(3000);
        return "test1";
    }
    static async Task<string> Test2Async()
    {
        await Task.Delay(3000);
        return "test2";
    }
}

运行结果如下：

  • Test1Async 和 Test2Async 中都延迟了 3 秒，但最终也只花了 3 秒；
  • 使用异步方法的 Result 属性或者调用 Wait() 方法，会进行阻塞。

返回值

使用 async 标记的异步方法可以有四种类型的返回值：

  • void
  • Task
  • Task
  • ValueTask

void

不推荐使用，有下面几个原因：

  • 因为使用 void 无法确定方法在什么时候调用完成；
  • 返回 void 的异步方法没有办法在调用的时候使用 await ；
  • 无法处理异常。

Task

没有返回值的异步方法，我们应该返回 Task：

  • 可以使用 Task 定义的变量来接收方法的返回值，该变量可以作为参数进行传递；
  • 方法在调用时可以使用 await 关键字；
  • 可以捕获状态，看下面例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("start"); 
        Task task1= Test1Async();
        Console.WriteLine($"是否完成：{task1.IsCompleted}");
        task1.Wait();
        Console.WriteLine($"是否完成：{task1.IsCompleted}");
        Console.WriteLine("end");
        Console.ReadLine();
    }
    static async Task Test1Async()
    {
        await Task.Delay(3000);
        Console.WriteLine("test1");
    }
}

执行结果：

Task

当异步方法需要返回一个值，给后面的步骤使用的的时候，就使用 Task ，在调用的时候使用 Result 属性进行值的获取。

ValueTask

ValueTask 是在 C#7.1 中推出的一种类型，使用 ValueTask 比 Task 更高效，该类型是一个 struct ，为值类型，在栈上分分配，不像 Task 是个 class ，频繁地分配和回收会对 GC 造成很大的压力。正因为 ValueTask 是个 struct ，在功能上要弱于 Task。 如果你的异步方法可以根据早前缓存的结果直接返回相应的值，应该使用 ValueTask 。

希望本文对您有所帮助。

许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

分享文章