Press "Enter" to skip to content

C#异步代码async/await解析,用await等待和同步阻塞有什么区别

先看这样一段常规代码:(假设两个耗时的方法为文件或数据库或网络请求操作)

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            var result = CallMethod();
            Console.WriteLine($"After method, Total: {result}");
            Console.ReadKey();
        }

        public static int CallMethod()
        {
            var a = Method1();
            var b = Method2();
            Console.WriteLine($"Result:{a}, {b}");
            return a + b;
        }

        public static int Method1()
        {
            Console.WriteLine("Method1 start.");
            Thread.Sleep(10000);
            Console.WriteLine("Method1 end in 10s.");
            return 1;
        }
        
        public static int Method2()
        {
            Console.WriteLine("Method2 start.");
            Thread.Sleep(5000);
            Console.WriteLine("Method2 end in 5s.");
            return 2;
        }
    }

执行结果:

Hello World!
Method1 start.
Method1 end in 10s.
Method2 start.
Method2 end in 5s.
Result:1, 2
After method, Total: 3

两个子方法运行分别需要10秒和5秒,所以整个方法总共需要15秒时间。

接下来我们把两个子方法转换成异步方法:

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            var res = Task.Run(CallMethod).GetAwaiter().GetResult();
            Console.WriteLine($"After method, Total: {res}");
            Console.ReadKey();
        }

        public static async Task<int> CallMethod()
        {
            var a = await Method1();
            var b = await Method2();
            Console.WriteLine($"Result:{a}, {b}");
            return a + b;
        }

        public static async Task<int> Method1()
        {
            var a = await Task.Run(() =>
            {
                Console.WriteLine("Method1 start.");
                Thread.Sleep(10000);
                Console.WriteLine("Method1 end in 10s.");
                return 1;
            });
            return a;
        }

        public static async Task<int> Method2()
        {
            var a = await Task.Run(() =>
            {
                Console.WriteLine("Method2 start.");
                Thread.Sleep(5000);
                Console.WriteLine("Method2 end in 5s.");
                return 2;
            });
            return a;
        }
    }

因为是在Console程序里,Main方法本身不允许加async参数,所以不能直接使用await,要使用GetResult方式获取异步结果。程序执行结果:

 Hello World!
 Method1 start.
 Method1 end in 10s.
 Method2 start.
 Method2 end in 5s.
 Result:1, 2
 After method, Total: 3

嗯?执行结果和顺序一模一样,执行时间也一样,还是15秒。await一个异步方法,和执行一个同步方法,效果是完全一样的吗?

我们来修改一下CallMethod方法:

        public static async Task<int> CallMethod()
        {
            var a = Method1();
            var b = Method2();
            var a1 = await a;
            var b1 = await b;
            Console.WriteLine($"Result:{a1}, {b1}");
            return a1 + b1;
        }

再执行一下,程序执行结果:

Hello World!
Method1 start.
Method2 start.
Method2 end in 5s.
Method1 end in 10s.
Result:1, 2
After method, Total: 3

OK,两个方法同时启动并行,时间短的先返回,时间长的后返回,但两个都返回以后,下面的代码才执行并返回。总执行时间变成了10秒。

唯一的区别是,把调用异步方法,和等待异步方法的结果,分成了两行来写。

这种情况下,如果是WebApi里面的某个接口,需要调用数据库执行5个不同的SQL语句(或者远程HTTP接口),将返回结果拼接起来返回给前端。如果每条SQL语句执行需要3秒(真是太慢了),那这个接口在顺序执行的情况下需要15秒才能返回,而在异步并行的情况下,总共只需要3秒。(前提是SQL数据库CPU没有受限)

接下来,假如CallMethod只需要执行几个异步任务,比如执行几个远程请求,再根据请求结果保存到数据库,并不需要返回结果,也就是void方法。把Main方法中调用的地方改成:

        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            Task.Run(CallMethod).Wait();
            Console.WriteLine($"After method.");
            Console.ReadKey();
        }

再运行一次:

Hello World!
Method1 start.
Method2 start.
After method.
Method2 end in 5s.
Method1 end in 10s.
Result:1, 2

结果虽然我们在Main方法里要求它等待CallMethod的执行,但是因为它是void方法,程序认为等待它的结果没有意义,然后就跳过了等待,继续执行了后面的代码。然后另外两个方法在后台默默的完成。如果是在一个WebApi的接口里,那结果就是接口立即返回了。