C# 多线程(18):一篇文章就理解async和await

内容纲要

前言

扯淡了 17 篇,这篇终于开始学习 async 和 await 了,有了前面的基础,来理解 async 和 await 就容易理解多了。

这一篇一定要按照每一个示例,去写代码、执行、输出结果,自己尝试分析思路。

async

微软文档:使用 async 修饰符可将方法、lambda 表达式或匿名方法指定为异步。

使用 async 修饰的方法,称为异步方法。

例如:

为了命名规范,使用 async 修饰的方法,需要在方法名称后面加上 Async

public async Task TestAsync()  
{  
    // . . . .  
}  

Lambda :


        static void Main()
        {
            Thread thread = new Thread(async () =>
            {
                await Task.Delay(0);
            });
        }
        public static async Task TestAsync() => 666;

await

微软文档:await 运算符暂停对其所属的 async 方法的求值,直到其操作数表示的异步操作完成。

异步操作完成后,await 运算符将返回操作的结果(如果有)。

好的,到此为止,async 和 await ,在官方文档中的说明,就这么多。

从以往知识推导

这里,你会跟笔者从以往文章中学习到的知识,去推导,去理解 async 和 await 这两个关键字是如何使用的,又应该怎么合理使用。

这里我们不参考文档和书籍的资料,不要看文档和书籍中的示例,我们要一步步来从任务(Task)中的同步异步开始,慢慢摸索。去分析 async 和 await 两个关键字给我们的异步编程带来了什么样的便利。

创建异步任务

场景:周六日放假了,可以打王者(一种游戏),但是昨天的衣服还没有洗;于是用洗衣机洗衣服,清洗期间,开一局王者(一种游戏)。

我们可以编写一个方法如下:

        static void Main()
        {
            Console.WriteLine("准备洗衣服");

            // 创建一个洗衣服的任务
            Task task = new Task(() =>
            {
                // 模拟洗衣服的时间
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });

            Console.WriteLine("开始洗衣服");

            // 让洗衣机洗衣服
            task.Start();

            Console.WriteLine("我去打王者,让洗衣机洗衣服");
            // 打王者
            Thread.Sleep(TimeSpan.FromSeconds(4));
            Console.WriteLine("打完王者了,衣服洗完了嘛?");

            Console.WriteLine(task.IsCompleted);
            if (task.IsCompleted)
                Console.WriteLine("洗衣服花的时间:" + task.Result);
            else
            {
                Console.WriteLine("在等洗衣机洗完衣服");
                task.Wait();
                Console.WriteLine("洗衣服花的时间:" + task.Result);
            }
            Console.WriteLine("洗完了,捞出衣服,晒衣服,继续打王者去");
        }

创建异步任务并返回Task

上面的示例,虽然说,异步完成了一个任务,但是这样,将代码都放到 Main ,可读性十分差,还要其它什么规范之类的,不允许我们写这样的垃圾代码。于是我们将洗衣服这个任务,封装到一个方法中,然后返回 Task 即可。

在 Program 类中,加入如下一个方法,这个方法用于执行异步任务,并且返回 Task 对象。


        /// 
        /// 执行一个任务
        /// 
        /// 
        public static Task TestAsync()
        {
            Task task = new Task(() =>
            {
                // 模拟洗衣服的时间
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });
            task.Start();
            return task;
        }

Main 方法中,改成

        static void Main()
        {
            Console.WriteLine("准备洗衣服");

            // 创建一个洗衣服的任务
            Task task = TestAsync();
            ... ...

但是,两者差别还是不大。

异步改同步

我们创建了异步方法,去执行一个洗衣服的任务;当打完游戏后,需要检查任务是否完成,然后才能进行下一步操作,这时候就出现了 同步。为了保持同步和获得执行结果,我们使用了 .Wait().Result

这里我们尝试将上面的操作转为同步,并且获得执行结果。

    class Program
    {
        static void Main()
        {
            int time = Test();
            // ... ...
        }

        /// 
        /// 执行一个任务
        /// 
        /// 
        public static int Test()
        {
            Task task = new Task(() =>
            {
                // 模拟洗衣服的时间
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });
            task.Start();
            return task.Result;
        }
    }

说说 await Task

TaskTask<TResult> ,前者是一个没有返回结果的任务,后者是有返回结果的任务。前面的文章中已经使用过大量的示例,这里我们使用 await ,去完成一些完全相同的功能。

Task

        public static void T1()
        {
            Task task = new Task(() => { });
            task.Wait();
        }
        public static async void T2()
        {
            Task task = new Task(() => {  });
            await task;
        }

说明,await 可以让程序等待任务完成。

Task<TResult>

        public void T3()
        {
            // 获取 Task 任务对象,后面的逻辑过程可以弄成异步
            Task task = TestAsync();

            // 任务是异步在执行,我不理会他
            // 这里可以处理其它事情,处理完毕后,再获取执行结果
            // 这就是异步

            Console.WriteLine(task.Result);
        }
        public async void T4()
        {
            // 使用 await 关键字,代表等待执行完成,同步
            int time = await TestAsync();
            Console.WriteLine(time);
        }

说明:await 可以让程序等待任务执行完成,并且获得执行结果。

看到没有。。。await 关键字,作用是让你等,是同步的,压根不是直接让你的任务变成异步后台执行的。

那为啥提到 async 、await,都是说跟异步有关?不急,后面解释。

说说 async Task<TResult>

async Task<TResult> 修饰一个方法,那么这个方法要返回 await Task<TResult> 的结果。

《C# 多线程(18):一篇文章就理解async和await》

两种同步方式示例对比:

        public static int Test()
        {
            Task task = new Task(() =>
            {
                // 模拟洗衣服的时间
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });
            task.Start();
            return task.Result;
        }
        public static async Task TestAsync()
        {
            Task task = new Task(() =>
            {
                // 模拟洗衣服的时间
                int time = new Random().Next(2, 6);
                Thread.Sleep(TimeSpan.FromSeconds(time));
                return time;
            });
            task.Start();
            int time = await task;
            return time;
        }

同步异步?

问:async 和 await 不是跟异步方法有关嘛,为啥前面的示例使用了 await ,全部变成同步了?

问:使用 async 和 await 的方法,执行过程到底是同步还是异步?

答:同步异步都行,要同步还是异步,全掌握在你的手上。

  • 你使用 await 去调用一个异步方法,其执行过程就是同步。
  • 你获取异步方法返回的 Task,就是异步。

最近笔者收到一些提问,有些读者,使用 async 和 await 去编写业务,想着是异步,可以提升性能,实际结果还是同步,性能一点没有提升。通过下面的示例,你会马上理解应该怎么用。

首先,在不使用 async 和 await 关键字的情况下,我们来编写两个方法,分别实现同步和异步的功能,两个方法执行的结果是一致的。

        /// 
        /// 同步
        /// 
        /// 
        public static int Test()
        {
            Task task = new Task(() =>
            {
                return 666;
            });
            task.Start();
            return task.Result;
        }

        /// 
        /// 异步
        /// 
        /// 
        public static Task TestAsync()
        {
            Task task = new Task(() =>
            {
                return 666;
            });
            task.Start();
            return task;
        }

能不能将两个方法合并在一起呢?想同步就同步,想异步就异步,这样就不需要写两个方法了!

是可以的!通过 async 和 await 关键字,可以轻松实现!

合并后,代码如下:

        /// 
        /// 可异步可同步
        /// 
        /// 
        public static async Task TestAsync()
        {
            Task task = new Task(() =>
            {
                return 666;
            });
            task.Start();
            return await task;
        }

合并后,我们又应该怎么在调用的时候,实现同步和异步呢?

笔者这里给出两个示例:

        // await 使得任务同步
        public async void T1()
        {
            // 使用 await 关键字,代表等待执行完成,同步
            int time = await TestAsync();
            Console.WriteLine(time);
        }

        // 直接获得返回的 Task,实现异步
        public void T2()
        {
            // 获取 Task 任务对象,后面的逻辑过程可以弄成异步
            Task task = TestAsync();

            // 任务是异步在执行,我不理会他
            // 这里可以处理其它事情,处理完毕后,再获取执行结果
            // 这就是异步

            Console.WriteLine(task.Result);
        }

至此,理解为什么使用了 asyncawait,执行时还是同步了吧?

Task封装异步任务

前面,我们都是使用了 new Task() 来创建任务,而且微软官网大多使用 Task.Run() 来编写 async 和 await 的示例。

因此,我们可以修改前面的异步任务,改成:

        /// 
        /// 可异步可同步
        /// 
        /// 
        public static async Task TestAsync()
        {
            return await Task.Run(() =>
            {
                return 666;
            });
        }

关于跳到 await 变异步

在百度学习异步的时候,往往会有作者说,进入异步方法后,同步执行代码,碰到 await 后就是异步执行。

当然还有多种说法。

我们已经学习了这么多的任务(Task)知识,这一点十分容易解释。

因为使用了 async 和 await 关键字,代码最深处,必定会出现 Task 这个东西,Task 这个东西本来就是异步。碰到 await 出现异步,不是因为 await 的作用,而是因为最底层有个 Task。

《C# 多线程(18):一篇文章就理解async和await》

《C# 多线程(18):一篇文章就理解async和await》

为什么出现一层层的 await

这是相对于提供服务者来说。因为我要提供接口给你使用,因此底层出现 async、await 后,我会继续保留方法是异步的(async),然后继续封装,这样就有多层的调用结构,例如上一小节的图。

但是如果来到了调用者这里,就不应该还是使用 async 、await 去编写方法,而是应该按照实际情况同步或异步。

通过本篇文章,理解 async 和 await 了吧?

点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注