等待所有或任意异步任务完成,以及异步任务完成时的处理方案

本篇体验如何等待所有异步任务完成、等待任意一个异步任务完成，以及异步任务完成时的处理。

等待一组任务的完成使用Task.WhenAll方法。

Task task1 = Task.Delay(TimeSpan.FromSeconds(1));
Task task2 = Task.Delay(TimeSpan.FromSeconds(2));
Task task3 = Task.Delay(TimeSpan.FromSeconds(3));
await Task.WhenAll(task1, task2, task3);

如果所有任务的结果类型相同且全部完成，Task.WhenAll返回每个任务执行结果的数组。

Task task1 = Task.FromResult(1);
Task task2 = Task.FromResult(2);
Task task3 = Task.FromResult(3);
int[] results = await Task.WhenAll(task1, task2, task3);
foreach(var item in results)
{
    Console.WriteLine(item);
}

举个例子，提供一个url的集合，要求根据这个url集合去远程下载对应的内容，写一个方法。

static async Task<string> DownloadAllAsync(IEnumerable<string> urls)
{
    var httpClient = new HttpClient();
    //定义每一个ulr的使用方法
    var downloads = urls.Select(url => httpClient.GetStringAsync(url));
    //下载真正开始
    Task<string>[] downloadTasks = downloads.ToArray();
    //异步等待
    string[] hmtls = await Task.WhenAll(downloadTasks);
    return string.Concat(htmls);
}

如果在等待所有任务完成的过程中有异常发生怎么办呢？

 

如果想在等待过程中捕获异常，那么应该把WhenAll方法放在try语句块中；如果想在所有任务完成后捕获异常，那就应该把WhenAll方法返回的Task类型放在try语句块中。

先模拟两个异步异常。

static async Task ThrowNotImplementedExceptionAsync()
{
    throw new NotImplementedException();
}
static async Task ThrowInvalidOperationExceptionAsync()
{
    throw new InvalidOperationException();
}

首先来看等待结果出来时的异常处理。

stati async Task ObserveOneExceptionAsync()
{
    var task1 = ThrowNotImplementedExceptionAsync();
    var task2 = ThrwoInvalidOperationExceptionAsync();
    try
    {
        await Task.WhenAll(task1, ask2);
    }
    cach(Exception ex)
    {
    }
}

再来看等所有结果出来后的异常处理。

static async Task ObserveAllExceptionAsync()
{
    var task1 = ThrowNotImplementedExceptionAsync();
    var task2 = ThrwoInvalidOperationExceptionAsync();
    Task allTasks = Task.WhenAll(task1, task2);
    try
    {
        await allTasks;
    }
    catch(Eexception ex)
    {
    }
}

等待任意一个任务的完成使用WhenAny方法。

 

比如有2个任务，通过2个url获取异步远程内容。

private static async Task<int> DownloadAsync(string url1, url2)
{
    var httpClient = new HttpClient();
    Task<byte[]> download1 = httpClient.GetByteArrayAsync(url1);
    Task<byte[]> download2 = httpClient.GetByteArrayAsync(url2);
    //等待任意一个任务完成
    Task<byte[]> completedTask = await Task.WhenAny(download1, download2);
    byte[] data = await completedTask;
    return data.Length;
}

任务完成时如何处理呢？

思路有2个，一个是根据我们安排的顺序出结果，还有一个是根据任务本身出结果的先后顺序自然输出结果。

首先来一个异步方法。

static async Task<int> DelayAsync(int val)
{
    await Task.Delay(TimeSpan.FromSeconds(val));
    return val;
}

再写一个手动部署任务顺序的方法。

static async Task ProcessTasksAsync()
{
    //创建任务队列
    Task<int> task1 = DelayAsync(2);
    Task<int> task2 = DelayAsync(3);
    Task<int> task3 = DelayAsync(1);
    //手动安排任务的顺序
    var tasks = new[]{task1, task2, task3};
    //按顺序遍历任务列表，逐一输出结果
    foreach(var task in tasks)
    {
        var result = await task;
        Console.Write(result);
    }
}

输出结果为231，是根据我们手动安排任务的顺序输出结果的。

如果我们想输出123呢？即按照任务的不同让结果自然发生。

思路是：以异步的方式处理输出结果。

 

可以写一个针对每个任务的异步方法。

static async Task AwaitAndProessAync(Task<int> task)
{
    var result = await task;
    Console.Write(result);
}

现在修改ProcessTasksAsync方法如下：

static async Task ProcessTasksAsync()
{
    //创建任务队列
    Task<int> task1 = DelayAsync(2);
    Task<int> task2 = DelayAsync(3);
    Task<int> task3 = DelayAsync(1);
    //手动安排任务的顺序
    var tasks = new[]{task1, task2, task3};
    var processingTasks = (from t in tasks
                        select AwaitAndProessAync(t)).ToArray();
     await Task.WhenAll(processingTasks);                    
}

当然，也可以这样修改ProcessTasksAsync方法。

static async Task ProcessTasksAsync()
{
    //创建任务队列
    Task<int> task1 = DelayAsync(2);
    Task<int> task2 = DelayAsync(3);
    Task<int> task3 = DelayAsync(1);
    //手动安排任务的顺序
    var tasks = new[]{task1, task2, task3};
    var processingTasks = tasks.Select( async t => {
        var result = await t;
        Console.Write(result);
    }).ToArray();
                        
     await Task.WhenAll(processingTasks);                    
}

参考资料：C#并发编程经典实例