首页 - 编程开发 - C/C++ - C#

C#中的Task.WaitAll和Task.WaitAny方法介绍

2023-02-06 05:26:20 苏内容

标签： C#

阅读：3528

一、简介

Task.WaitAll：等待所有提供的 Task 对象完成执行过程。

Task.WaitAny：等待提供的任一 Task 对象完成执行过程。

二、代码案例

Task.WaitAll

代码：

    class Program
    {
        public class DownLoadTest
        {
            Stopwatch watch = new Stopwatch();
            public  DownLoadTest()
            {
                watch.Start();
            }
                
            public async Task DoRunTaskAsync(string url, CancellationToken ct)
            {
                if (ct.IsCancellationRequested)
                {
                    Console.WriteLine(string.Format("取消{0}的運行 :{1,4:N0}ms", url, watch.Elapsed.TotalMilliseconds));
                    return;
                }
                Console.WriteLine(string.Format("下載{0}開始運行 :{1,4:N0}ms", url, watch.Elapsed.TotalMilliseconds));
                WebClient wc = new WebClient();
                await Task.Run(() =>
                {
                    var task = wc.DownloadStringTaskAsync(url);
                    while (!task.IsCompleted)
                    {
                        if (ct.IsCancellationRequested)
                        {
                            Console.WriteLine(string.Format("取消{0}的運行 :{1,4:N0}ms", url, watch.Elapsed.TotalMilliseconds));
                            return;
                        }
                    }
                    if (task.IsCompleted)
                        Console.WriteLine(string.Format("下載{0}運行結束 :{1,4:N0}ms", url, watch.Elapsed.TotalMilliseconds));
                });
            }
        }

        static void Main(string[] args)
        {

            DownLoadTest dwtest = new DownLoadTest();
            CancellationTokenSource cts = new CancellationTokenSource();
            CancellationToken token = cts.Token;
            var task1 = dwtest.DoRunTaskAsync("https://www.baidu.com/", token);
            var task2 = dwtest.DoRunTaskAsync("https://www.taobao.com/", token);
            var task3 = dwtest.DoRunTaskAsync("https://www.cnblogs.com/", token);
            Task[] tasks = new Task[] { task1, task2, task3 };
            Console.WriteLine("task.Result等待結果打印");
            Task.WaitAll(tasks, 10000);
            cts.Cancel();//超过10s时间取消运行
            Console.WriteLine(task1.Status);
            Console.WriteLine(task2.Status);
            Console.WriteLine(task3.Status);
            Console.WriteLine(string.Format("主線程運行結束"));
            Console.ReadKey();
        }
    }

运行结果：

通过运行结果可以看出，可以看到Task.WaitAll(tasks)在等待超时的时间内，同步等待了所有的任务完成。

Task.WaitAny

代码：

    class Program
    {
        public class DownLoadTest
        {
            Stopwatch watch = new Stopwatch();
            public  DownLoadTest()
            {
                watch.Start();
            }
                
            public async Task DoRunTaskAsync(string url, CancellationToken ct)
            {
                if (ct.IsCancellationRequested)
                {
                    Console.WriteLine(string.Format("取消{0}的運行 :{1,4:N0}ms", url, watch.Elapsed.TotalMilliseconds));
                    return;
                }
                Console.WriteLine(string.Format("下載{0}開始運行 :{1,4:N0}ms", url, watch.Elapsed.TotalMilliseconds));
                WebClient wc = new WebClient();
                await Task.Run(() =>
                {
                    var task = wc.DownloadStringTaskAsync(url);
                    while (!task.IsCompleted)
                    {
                        if (ct.IsCancellationRequested)
                        {
                            Console.WriteLine(string.Format("取消{0}的運行 :{1,4:N0}ms", url, watch.Elapsed.TotalMilliseconds));
                            return;
                        }
                    }
                    if (task.IsCompleted)
                        Console.WriteLine(string.Format("下載{0}運行結束 :{1,4:N0}ms", url, watch.Elapsed.TotalMilliseconds));
                });
            }
        }

        static void Main(string[] args)
        {

            DownLoadTest dwtest = new DownLoadTest();
            CancellationTokenSource cts = new CancellationTokenSource();
            CancellationToken token = cts.Token;
            var task1 = dwtest.DoRunTaskAsync("https://www.baidu.com/", token);
            var task2 = dwtest.DoRunTaskAsync("https://www.taobao.com/", token);
            var task3 = dwtest.DoRunTaskAsync("https://www.cnblogs.com/", token);
            Task[] tasks = new Task[] { task1, task2, task3 };
            Console.WriteLine("task.Result等待結果打印");
            Task.WaitAny(tasks, 4000);
            cts.Cancel();//超过4s时间取消运行
            Console.WriteLine(task1.Status);
            Console.WriteLine(task2.Status);
            Console.WriteLine(task3.Status);
            Console.WriteLine(string.Format("主線程運行結束"));
            Console.ReadKey();
        }
    }

运行结果：

通过运行结果截图可以看出，可以看到，Task.WhenAny(tasks)至少等待了一个任务的完成。这里https://www.baidu.com/先下载完，就直接终止等待。

三、总结

Task.WaitAll阻止当前线程，直到所有其他任务完成执行为止。Task.WaitAny阻止当前线程，至少等待一个任务完成执行为止。如果等待时长设置较长，上述案例结果会一样。

using System.Net.Http;

using System.Threading.Tasks;

using static System.Console;

namespace Core

{

class Async

{

static void Main()

{

Start();

End();

}

static void Wait()=>WriteLine("waiting...");

static void End()=>WriteLine("end...");

static int Start()

{

WriteLine("start...");

HttpClient client = new HttpClient();

Waiting();

var result = client.GetStringAsync("https://www.visualstudio.com/");

string str = result.Result;

return str.Length;

}

上面这段代码中，Main方法中的代码是按照自上而下的顺序执行的。网络状况不佳时，Start()方法是比较耗时（注意，这里在Start方法中调用了异步方法GetStringAsync，但该方法在此处是以同步方式执行的，具体原因下文会进行说明），在Start()方法执行完毕之前，整个程序处于阻塞状态。而异步编程可以很好的解决这个问题，一句简单的话来概括异步编程就是，程序无须按照代码顺序自上而下的执行。

async/await

C#5.0新增了async和await关键字，使用这两个关键字可以大大简化异步编程

使用 async 关键字可将方法、lambda 表达式或匿名方法标记为异步，即，方法中应该包含一个或多个await表达式，但async关键字本身不会创建异步操作。

public async Task Asy()
{
　　//do something...
}

这里需要注意一点，若使用async关键字标记的方法中没有使用await关键字（编译器会给出警告但不报错），那么该方法将会以同步方式执行。

定义异步方法的几点要求

定义一个异步方法应满足以下几点：

使用async关键字来修饰方法
在异步方法中使用await关键字（不使用编译器会给出警告但不报错），否则异步方法会以同步方式执行
尽量不使用void作为返回类型，若希望异步方法返回void类型，请使用Task
异步方法名称以Async结尾
异步方法中不能声明使用ref或out关键字修饰的变量

下面定义一个异步方法StartAsync()：

static async Task<int> StartAsync()
{
    HttpClient client = new HttpClient();
    var str = await client.GetStringAsync("https://www.visualstudio.com/");
    return str.Length;
}

异步方法的返回类型

Task<T>
如果在调用匿名方法时使用了await关键字，且匿名方法的返回类型是Task<T>，那么我们得到的返回类型是T。若未使用await关键字，则返回类型是Task。未使用await，调用GetStringAsync方法时result是Task类型。

从上图我们可以看到调用GetStringAsync方法时未使用await关键字，result是Task类型，我们可以通过GetType()方法来获取result的详细类型信息：

从上图可以看到result的类型全名是System.Threading.Tasks.Task

从上图我们可以看到使用await关键字时，result是string类型，而匿名方法GetStringAsync的返回类型是Task<string>

Task
如果在调用匿名方法时使用了await关键字，且匿名方法的返回类型是Task，那么我们得到的返回类型是void。若为使用await关键字，则得到的返回类型是Task。
void
不建议使用void作为异步方法的返回值。
因为使用Task或Task<TResult>任务作为返回值，其属性携带有关其状态和历史记录的信息，如任务是否完成、异步方法是否导致异常或已取消以及最终结果是什么。而await运算符可访问这些属性。

异步方法执行流程

异步程序执行流程

上图是微软官方提供的讲解异步程序执行流程的图示，并附有解释说明：

The numbers in the diagram correspond to the following steps.
An event handler calls and awaits the AccessTheWebAsync async method.
AccessTheWebAsync creates an HttpClient instance and calls the GetStringAsyncasynchronous method to download the contents of a website as a string.
Something happens in GetStringAsync that suspends its progress. Perhaps it must wait for a website to download or some other blocking activity. To avoid blocking resources, GetStringAsync yields control to its caller, AccessTheWebAsync.
GetStringAsync returns a Task<TResult> where TResult is a string, and AccessTheWebAsync assigns the task to thegetStringTask variable. The task represents the ongoing process for the call to GetStringAsync, with a commitment to produce an actual string value when the work is complete.
Because getStringTask hasn't been awaited yet, AccessTheWebAsync can continue with other work that doesn't depend on the final result from GetStringAsync. That work is represented by a call to the synchronous method DoIndependentWork.
DoIndependentWork is a synchronous method that does its work and returns to its caller.
AccessTheWebAsync has run out of work that it can do without a result from getStringTask. AccessTheWebAsync next wants to calculate and return the length of the downloaded string, but the method can't calculate that value until the method has the string.
Therefore, AccessTheWebAsync uses an await operator to suspend its progress and to yield control to the method that called AccessTheWebAsync. AccessTheWebAsync returns a Task<int> to the caller. The task represents a promise to produce an integer result that's the length of the downloaded string.
Note
If GetStringAsync (and therefore getStringTask) is complete before AccessTheWebAsync awaits it, control remains inAccessTheWebAsync. The expense of suspending and then returning to AccessTheWebAsync would be wasted if the called asynchronous process (getStringTask) has already completed and AccessTheWebSync doesn't have to wait for the final result.
Inside the caller (the event handler in this example), the processing pattern continues. The caller might do other work that doesn't depend on the result from AccessTheWebAsync before awaiting that result, or the caller might await immediately. The event handler is waiting for AccessTheWebAsync, and AccessTheWebAsync is waiting for GetStringAsync.
GetStringAsync completes and produces a string result. The string result isn't returned by the call to GetStringAsync in the way that you might expect. (Remember that the method already returned a task in step Instead, the string result is stored in the task that represents the completion of the method, getStringTask. The await operator retrieves the result from getStringTask. The assignment statement assigns the retrieved result to urlContents.
When AccessTheWebAsync has the string result, the method can calculate the length of the string. Then the work ofAccessTheWebAsync is also complete, and the waiting event handler can resume. In the full example at the end of the topic, you can confirm that the event handler retrieves and prints the value of the length result.
If you are new to asynchronous programming, take a minute to consider the difference between synchronous and asynchronous behavior. A synchronous method returns when its work is complete (step 5), but an async method returns a task value when its work is suspended (steps 3 and 6). When the async method eventually completes its work, the task is marked as completed and the result, if any, is stored in the task.

解释虽是英文，但并没有太难的单词，是可以看懂其意思的。通过上面的说明，我们可以知道：
在遇到awiat关键字之前，程序是按照代码顺序自上而下以同步方式执行的。
在遇到await关键字之后，系统做了以下工作：

异步方法将被挂起
将控制权返回给调用者
使用线程池中的线程（而非额外创建新的线程）来计算await表达式的结果，所以await不会造成程序的阻塞
完成对await表达式的计算之后，若await表达式后面还有代码则由执行await表达式的线程（不是调用方所在的线程）继续执行这些代码

使用一段代码来进行验证：

static void Main()
{
    Task<int> task = StartAsync();
    Thread.Sleep(5000);
    End();
}

static async Task<int> StartAsync()
{
    WriteLine("start...");
    HttpClient client = new HttpClient();
    var result = client.GetStringAsync("https://www.visualstudio.com/");
    string str = await result;
    return str.Length;
}

执行代码

从上图左侧的调用栈中可以看到，在遇到await关键字之前，异步方法StartAsync自上而下同步执行。注意，这里异步方法GetStringAsync方法是被挂起的，不会造成程序的阻塞，控制权回到调用者StartAsync中，仔细看英文解释中的第3步。
然后在Debug Console中输入System.Threading.Thread.Current查看当前工作线程信息，以及System.Threading.Thread.CurrentThread.IsThreadPoolThread查看当前线程是否在线程池中。

从上图我们看到，当前线程Id是1，不在线程池中。继续执行程序：

遇到await关键字后，异步方法StartAsync被挂起，控制权也回到了调用者Main方法中。

从上图我们可以看到异步方法StartAsync中的result变量的Status属性值是WaitingForActivation，Result属性值是Not yet computed。

代码继续执行，将Main方法所在线程接挂起5秒，系统使用线程池中的线程计算await表达式的值：

从上图我们可以看到，程序已经成功计算出await表达式的值，变量result的Status属性值变成了RanToCompletion。完成对await表达式的计算之后，程序继续执行后面的代码(return str.Length)。

再看此时的工作线程信息：

我们看到，当前线程Id是5且存在于线程池中。

从这里我们可以得知异步是借助于多线程来实现的。

Task

Task类拥有执行异步方法的两个方法：Task.Run(),Task.Run<T>，Task.Run以及Task.Run<T>使用线程池中的线程来执行代码，它和使用await关键字的区别是：Task.Run直接使用线程池中的线程，而使用await的异步方法是在遇到await关键字后才使用多线程。

Thread

线程是前面所说的异步（async/await）和任务（Task）的基础。和线程紧密相关的另外一个概念是进程，这里不多赘述。

ThreadPool

线程也是对象，频繁的创建和销毁线程比较影响性能，.NET提供线程池使得我们能够复用线程对象从而避免频繁创建和销毁线程。

结语

自己创建线程比较麻烦但能够更好的控制程序的运行，使用async/await关键字来编码显得较为简洁，但对程序的控制力度会有所降低。

参考文章：

Asynchronous Programming with async and await (C#)
async
await
走进异步编程的世界 - 开始接触 async/await
C#执行异步操作的几种方式比较和总结
thread task parallel plinq async await多线程任务及异步编程
走进异步编程的世界 - 在 GUI 中执行异步操作

Async/Await - Best Practices in Asynchronous Programming

扩展阅读

[C#] C#在非主线程获取剪切板内容
[C#] C#中的Task.WaitAll和Task.WaitAny方法介绍
[C#] C++调用C#动态库
[C#] C# 彻底搞懂async/await
[C#] 解决C#调用执行js报检索 COM 类工厂中 CLSID 为 {0E59F1D5-1FBE-11D0-8FF2-00A0D10038BC} 组件失败