C#并行编程（5）：需要知道的异步

异步与并行的联系

大家知道“并行”是利用CPU的多个核心或者多个CPU同时执行不同的任务，我们不关心这些任务之间的依赖关系。
但是在我们实际的业务中，很多任务之间是相互影响的，比如统计车间全年产量的运算要依赖于各月产量的统计结果。假如你想在计算月产量的时候做些其他事情，如导出生产异常报表，“异步”就可以登上舞台了。

说到异步，必须要先提一下同步。一图胜千言：

图中操作C的执行依赖B的结果，B的执行依赖A的结果。线程1连续执行操作A、B、C便是一个同步过程；相对地，线程1执行完A后把结果给线程2，线程2开始执行B，完成后把B的结果通知到线程1，线程1开始执行C,线程1在等待操作B结果的时候执行了D，这就是一个异步的过程；此外，异步过程中，B和D是并行执行的。

并行会提高业务的执行效率，但异步不会，异步甚至会拖慢业务的执行，比如上面A->B->C的执行过程。异步是让等待变得更有价值,这种价值则体现在多个业务的并行上。

C#中的异步

在需要长时间等待的地方都可以使用异步，比如读写文件、访问网络或者处理图片。特别是在UI线程中，我们要保持界面的响应性，耗时的操作最好都使用异步的方式执行。

.NET提供了三种异步模式：

• IAsyncResult模式（APM）
• 基于事件的异步模式（EAP）
• 基于任务的异步模式（TAP）

其中基于任务的异步模式是.NET推荐的异步编程方式。

IAsyncResult异步模式APM

下面是IAsyncResult基于委托的用法。

/// <summary>
/// 做作业的委托
/// </summary>
/// <param name="workNo">作业编号</param>
private delegate void AsyncWorkCaller(int workNo);

public static void Run()
{
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} will do some work.");
AsyncWorkCaller caller = DoWork;
AsyncCallback callback = ar =>
{// 异步任务完成后的回调，在异步任务的执行线程中执行
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} did the callback. [{ar.AsyncState}]");
};
IAsyncResult result = caller.BeginInvoke(1, callback, "callback msg");
DoWork(2);
//result.AsyncWaitHandle.WaitOne();
caller.EndInvoke(result);
DoWork(3);
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} done the work.");
}

/// <summary>
/// 做作业
/// </summary>
/// <param name="workNo">作业编号</param>
private static void DoWork(int workNo)
{
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> work #{workNo} started with thread #{Thread.CurrentThread.ManagedThreadId}.");
Thread.Sleep(1000);//模拟耗时
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> work #{workNo} done with thread #{Thread.CurrentThread.ManagedThreadId}.");
}

我们使用

BeginInvoke

EndInvoke

result.AsyncWaitHandle.WaitOne()

基于事件的异步模式EAP

事件大家不会陌生，我们在Winform编程的时候，总会用到事件。下面是利用

BackgroundWorker

DoWork

RunWorkCompleted

RunWorkerAsync

IAsyncResult

IAsyncResult

public static class EventBasedAsync
{
private static readonly BackgroundWorker worker = new BackgroundWorker();

static EventBasedAsync()
{
worker.DoWork += Worker_DoWork;
worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
}

public static void Run()
{
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} will do some work.");
worker.RunWorkerAsync(1);
DoWork(2);
DoWork(3);
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} done the work.");
}

private static void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{//作业完成后，会开辟新的线程执行指定的操作
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} did something when work completed.");
}

private static void Worker_DoWork(object sender, DoWorkEventArgs e)
{//作业会运行在新的线程里
DoWork((int)e.Argument);
}

/// <summary>
/// 做作业
/// </summary>
/// <param name="workNo">作业编号</param>
private static void DoWork(int workNo)
{
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> work #{workNo} started with thread #{Thread.CurrentThread.ManagedThreadId}.");
Thread.Sleep(3000);//模拟耗时
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> work #{workNo} done with thread #{Thread.CurrentThread.ManagedThreadId}.");
}
}

实际上，我们可以利用

AsyncOperationManager

BackgroundWorker

基于任务的异步模式TAP

在《C#并行编程（4）：基于任务的并行》中，我们已经总结过

Task

Task<T>

async/await

Task

在C#中，我们使用async标记定义一个异步方法，使用await来等待一个异步操作。简单的用法如下：

public async Task DoWorkAsync()
{
await Task.Delay(1000);
}

public async Task<int> DoWorkAndGetResultAsync()
{
await Task.Delay(1000);
return 1;
}

用

async/await

public static async Task Run()
{
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} will do some work.");

Task workTask1 = DoWork(1); // 不使用await调用的异步方法，与正常方法一样
//await workTask1;
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} got task #{workTask1.Id} by async call.");

Task workTask2 = DoWork(2);
await workTask2;
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} got task #{workTask2.Id} by async call.");

Task workTask3 = DoWork(3);
await workTask3;
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} got task #{workTask3.Id} by async call.");

Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> thread #{Thread.CurrentThread.ManagedThreadId} done the work.");
}

/// <summary>
/// 异步作业
/// </summary>
/// <param name="workNo">作业编号</param>
/// <returns>异步任务</returns>
private static async Task DoWork(int workNo)
{
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> work #{workNo} started with thread #{Thread.CurrentThread.ManagedThreadId}.");
DateTime now = DateTime.Now;
await Task.Run(() =>
{
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> work #{workNo} was running by task #{Task.CurrentId} with thread #{Thread.CurrentThread.ManagedThreadId}.");
while (now.AddMilliseconds(3000) > DateTime.Now)
{// 模拟计算过程
}
});
Console.WriteLine($"{DateTime.Now:HH:mm:ss.ffffff}=> work #{workNo} done with thread #{Thread.CurrentThread.ManagedThreadId}.");
}

先来看一下例子的输出：

在上面的输出中，我们单看work #1,它由thread #10启动，计算过程在thread #6中执行并结束，最后任务在thread #10中返回，这里我们没有使用

await

await

await

Run()

DoWork()

await

实际上，编译器会把异步方法转换成状态机结构，执行到

await

await

理解异步方法的执行机制后，相信对异步的应用会变得更加娴熟，这里就不再总结异步的具体用法。