异步方法—Async、Await

一：前言

1.所有带有Async关键字的异步方法返回类型：

　　　　① Task<T>：如果调用方法想通过调用异步方法获取一个T类型的返回值，那么签名必须为Task<TResult>；

　　　　② Task:如果调用方法不想通过异步方法获取一个值，仅仅想追踪异步方法的执行状态，那么我们可以设置异步方法签名的返回值为Task;

　　　　③ void:如果调用方法仅仅只是调用一下异步方法，不和异步方法做其他交互，我们可以设置异步方法签名的返回值为void，这种形式也叫做“调用;

即：异步方法的返回值类型必须为Task或Task<T>；

2.异步方法的“传染性“：一个方法中如果有await调用，则这个方法也必须修饰为async。

3.在async方法中遇到await关键字后，当前线程立即返回(到调用方)，继续之前的处理逻辑；await关键字之后的代码逻辑，将交由新的线程处理；当新的线程处理完成后，可以从新的线程返回处理结果到调用(处)线程当中，结束等待。

4.在一个async方法中，会根据await关键字进行分割，拆分到不同的线程处理同一个方法的不同部分！如下例：

 static void Main(string[] args)
        {
            Console.WriteLine("{0}->Main.异步方法执行前", Thread.CurrentThread.ManagedThreadId.ToString());//输出异步处理之前的线程ID
            DoAsync(1000).Wait();//执行异步处理，并等待该异步方法执行完成后才继续
            Console.WriteLine("{0}->Main.异步方法执行后", Thread.CurrentThread.ManagedThreadId.ToString());//输出异步处理之后的线程ID

            Console.Read();
        }


        /// <summary>
        /// 执行异步处理
        /// </summary>
        /// <param name="times">模拟处理时长</param>
        /// <returns></returns>
        public static async Task DoAsync(int times)
        {
            Console.WriteLine("{0}->DoAsync.await之前", Thread.CurrentThread.ManagedThreadId.ToString());//输出调用线程ID
            await Task.Run(() => Thread.Sleep(times));///执行一个异步任务，并等待返回结果才继续；需要注意的是，调用线程执行到这一行的时候其实就已经返回了
            Console.WriteLine("{0}->DoAsync.await之后", Thread.CurrentThread.ManagedThreadId.ToString());//异步操作执行完了，但这里已经是新的线程了
        }

运行结果：

请注意：在同步方法Main中执行的时候都是同一个线程；在异步方法DoAsync执行的时候，在await之前是调用线程，在await之后则是另一个线程。

5.把一个方法代码的不同部分拆分到多个线程处理，这是异步方法和同步方法的最大不同！

总而言之：

在异步(async)方法执行中，会根据await关键字，拆分一个方法为多个部分，分别由不同的线程执行。

在异步(async)方法执行中，遇到await关键字，调用线程会立即返回(线程池)继续后续的处理逻辑；而后，调用方可以使用Task.Wait()或Task<T>.Result进行阻塞，等待异步方法执行完毕再继续。

在异步(async)方法执行后，若不使用Task.Wait()进行等待，或不使用Task<T>.Result获取返回结果，则该方法将仅以异步方式执行。

二：详解Async和await关键字

1.Async和await细节

async和await可以创建和使用异步方法，这个特性的由三个部分组成：

①调用方法(calling method)：该方法调用异步方法，然后在异步方法（可能使用同一个线程也可能不在一个线程）执行其任务的时候继续执行

②异步方法（async）: 该方法异步执行其工作，然后立即方法到调用方法

③await表达式：用于异步方法内部，指明需要异步执行的惹怒我。一个异步方法可以包含任意多个await表达式，如果一个都不包含编译器会发出警告

//1.调用方法
static void Main(string[] args)
{
    Task<int> t = DoSumAsync(1, 2);
    Console.WriteLine("结果:{0}", t.Result);
    Console.ReadKey();
}
 
//2.异步方法
public static async Task<int> DoSumAsync(int a, int b)
{
    //3.await 表达式
    int sum = await Task.Run(() => { return a + b; });
    return sum;
}

2.什么是异步？

异步方法在完成其工作之前返回到调用方法，并在调用方法继续执行的时候完成其工作。语法上有如下特征：

① 方法使用async作为修饰符

② 方法内部包含一个或者多个await表达式，表示可以异步完成的任务

③ 必须具备以下三种返回类型 void 、Task 、Task<T> ,其中后两种的返回对象标识讲座未来完成的工作，调用方法和异步方法可以继续执行。

④异步方法的参数可以任意类型，但是不能为out和ref参数

⑤约定俗成，一般异步方法都是以 Async作为后缀的。

⑥ 除了方法之外，Lambda表达式和匿名函数也可以作为异步对象。

private async Task<int> CountCharactersAsync(int id, string uriString)
{
    WebClient wc = new WebClient();
    Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds);
    string result = await wc.DownloadStringTaskAsync(new Uri(uriString));
    Trace.TraceInformation("Taceing Async Call {0} @time:{1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    return result.Length;
}

详细说明：

①async关键字是一个上下文关键字，也就是说除了做为方法（lambda和匿名函数）的修饰符之外，还可以做标识符。

②返回类型

Task类型：如果调用方法不需要从异步方法中返回某个值，但需要检查异步方法的状态，可以返回一个Task，此时就算异步方法中出现了return语句，也不会返回任何东西。

Task<T>类型，除了上面Task的功能，还可以通过 Return属性来获取返回的T类型的值。

void类型：如果仅仅是执行异步方法，而不需要与它做任何进一步的交互（“调用并忘记”），此时可以用void，和Task一样，就算有return语句，也得不到任何东西。

3.异步方法的控制流

首先要明确“异步方法”的三个部分，如下图所示：

①首先是第一个await之前的部分，这部分应该是少量且无需长时间等待的代码。

②await表达式，表示需要被异步执行的任务，这里有两个await表达式，第二个await和之前的同步部分和第一个await以及之前的部分是一样的。

③后续部分：在await表达式之后出现的方法中的其余代码。

执行过程：

有几个注意的地方：

① await之前的部分是同步执行的

② 当达到awati的时候，会将异步方法的控制返回给调用方法。如果方法返回的类型是Task或者Task<T>，将创建一个Task对象，表示需异步完成的任务和后续，然后将该Task返回到调用方法。这里的返回值并不是await表达式的返回值，而是异步方法中声明的返回值类型。

③ 异步方法内部需要完成以下工作：

　　- 异步执行await表达是的空闲任务

- 当await表达式执行完成之后，执行后续部分。后续本身也可能是await表达式，处理过程和上一个一致。

　　- 后续部分如果遇到 return 或者方法达到末尾，将做如下的事情：

　　　　l 如果返回的类型是void,控制流就退出了

　　　　l 如果返回的类型是Task，后续部分设置Task对象的属性并退出。

　　　　l 如果返回的类型是Task<T>，不仅要设置Task对象属性，还要设置Task对象的Return属性。

　　这个点要注意下：并不是遇到return或者达到方法末尾，就能获取到返回值，它只是退出了。

④ 调用方法继续执行，会从异步方法获取Task对象。当需要其实际值的时候，就引用Task对象中的Result属性。届时，如果异步方法设置了该属性，调用方法获取其值并继续。否则就等待该属性被设置，然后再继续执行。

4.await表达式

await表达式指定了一个异步执行的任务。语法由 await关键字 + 一个空闲对象(称为任务)组成。这个任务可能是一个Task对象，也可以不是，默认情况下由该线程异步执行。

一个空闲对象指的是一个awaitable类型的实例，awaitable类型是指包含了GetAwaiter方法的类型，方法没有参数，返回一个称为awaiter类型的对象。

一个awaiter对象包含了如下成员：

一般情况下我们不需要自己构建一个awaiter对象，使用.net 自己的Task就可以了。最简单的方法就是使用Task.Run()来返回一个Task对象。关于Task.Run()有一个非常重要的点，他将在不同的线程上运行你的方法。

5.异常处理和await表达式

static void Main(string[] args)
{
 
    Task t = BadAsync();
    t.Wait();
    Console.WriteLine("Task Status:       {0}", t.Status );
    Console.WriteLine("Task IsFaulted:    {0}", t.IsFaulted );
    Console.WriteLine("Please enter a key to exit!");
    Console.ReadKey();
 
}
 
static async Task BadAsync()
{
    try
    {
        await Task.Run(() => { throw new Exception(); });
    }
    catch
    {
        Console.WriteLine("Exception in BadAsync");
    }
}

运行结果：

从结果可以看到，虽然在异步方法内部进行了try..catch，并且也catch到了异常，但是对于调用函数，返回的Task状态依然为 RanToCompletion 。

为什么这个亚子？，原因如下：

① Task没有被取消掉

② 没有未处理的异常。类似的IsFaulted是false。

6.在调用方法中同步的等待任务（WaitAll、WaitAny）

对于单个Task，可以通过task对象的wait方法等待：

Task<int> t = CountCharactersAsync("http://www.163.com");
t.Wait();

对于多个Task，可以使用WaitAll()或者WaitAny()方法，进行同步：

Task<int> t1 = CountCharactersAsync(1, "http://www.163.com");
Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com");
Task<int>[] tasks = new Task<int>[] { t1, t2 };
Task.WaitAll(tasks);

WaitAny是只要一个完成就可以继续操作：

Task<int> t1 = CountCharactersAsync(1, "http://www.163.com");
Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com");
Task<int>[] tasks = new Task<int>[] { t1, t2 };
Task.WaitAny(tasks);

7.在异步方法中异步的等待任务（WhenAll、.WhenAny）

上面说明了如何在“调用方法”中，同步等待Task的完成。但是有时候，我们在一个异步方法中也会存在多个任务，想要让它们通过await表达式等待。我们可以通过Task.WhenAll() 和 Task.WhenAny() 方法实现。这两个方法称为组合子（combinator）。

private async Task<int> CountCharactersAsync(string site1, string site2)
{
    WebClient wc1 = new WebClient();
    WebClient wc2 = new WebClient();
 
    Task<string> t1 = wc1.DownloadStringTaskAsync(new Uri(site1));
    Task<string> t2 = wc2.DownloadStringTaskAsync(new Uri(site2));
 
    List<Task<string>> tasks = new List<Task<string>>();
    tasks.Add(t1);
    tasks.Add(t2);
 
    //组合子
    await Task.WhenAll(tasks);
    //await Task.WhenAny(tasks);
 
    Console.WriteLine("   CCA:  T1 {0} Finished", t1.IsCompleted ? "" : "Not");
    Console.WriteLine("   CCA:  T2 {0} Finished", t2.IsCompleted ? "" : "Not");
 
    return t1.IsCompleted? t1.Result.Length: t2.Result.Length;
}

8.使用Task.Delay暂停线程处理

一般我们都使用Thread.Sleep(xxxx) 进行线程的延时，但是 Thread.Sleep会阻塞线程。而Task.Delay则不会阻塞线程，线程可以继续处理其他的工作。

class Simple
{
    Stopwatch sw = new Stopwatch();
    public void DoRun()
    {
        Console.WriteLine("Caller: Before call");
        ShowDelayAsync();
        Console.WriteLine("Caller: After call");
 
    }
    private async void ShowDelayAsync()
    {
        sw.Start();
        Console.WriteLine("   Before Delay:  {0} ", sw.Elapsed.Milliseconds );
        await Task.Delay(1000);
        Console.WriteLine("   After  Delay:  {0} ", sw.Elapsed.Milliseconds);
    }
}

posted @ 2021-10-19 17:47 答辉阅读(3072) 评论(0) 编辑收藏举报

刷新页面返回顶部

答辉