async/await的特殊的地方

一：async如果是用于方法声明里，那么要求这个方法的返回值必须是Task、Task<TResult>、void这三种，而且await出现的地方要求其所在的方法必须是async修饰的方法；

不过void的最好不要用，如果说方法没有返回值用Task，有返回值用Task<TResult>；

先看两段代码：

①

static void Main(string[] args)
        {
            var task = FooAsync();
            // Result的get方法会阻塞当前线程直到task执行完毕
            Console.WriteLine(task.Result);
            Console.WriteLine("Hello World!");
        }

        static async Task<int> FooAsync()
        {
　　　　　　　// await task对象可以直接获取task对象执行完毕的返回值，因此await会将Task.Run(..)作为同步块；
            int result = await Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine($"{nameof(FooAsync)}方法耗时3秒执行完毕");
                return 8;
            });
            return result;
        }

②

static void Main(string[] args)
        {
            var task = FooAsync();
            // Result的get方法会阻塞当前线程直到task执行完毕
            Console.WriteLine(task.Result);
            Console.WriteLine("Hello World!");
        }

　　　　　// TODO 注意，这个地方去掉了async和里面的await
        static Task<int> FooAsync()
        {
            // 这时候不能用int作为变量类型了
            Task<int> result = Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine($"{nameof(FooAsync)}方法耗时3秒执行完毕");
                return 8;
            });
            return result;
        }

　　对于上面的async和await的写法，那么async和await关键字其实可以说一点用处也没有，直接通过Task就能达到完全一模一样的效果；

接着来看另一种写法：

static void Main(string[] args)
        {
            var task = FooAsync();
            // Result的get方法会阻塞当前线程直到task执行完毕
            Console.WriteLine(task.Result);
            Console.WriteLine("Hello World!");
        }

        /**
         * 注意，Task是后台任务（由后台线程执行），而Java的Task，或者说Java默认的线程创建工厂创建的线程是前台线程
         */
        static async Task<string> FooAsync()
        {
            // 这时候不能用int作为变量类型了
            Task<int> result = Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine($"{nameof(FooAsync)}方法耗时3秒执行完毕");
                return 8;
            });
            int resultValue = await result;
            return "333N" + resultValue;  // TODO 注意这里多了转换结果的步骤，用async+await写这种需求很方便，如果只用Task那么就得把Task.Run(...)提升到外部调用的地方才能方便的实现这个功能；
        }

　　这种写法只用Task<TResult>就不容易实现了，至少写起来要多蛮多步骤（需要再手动写个Task<string>对象然后用lambda表达式将await出来的结果转换为string返回出来，然后返回这个new出来的Task<string>对象）；

然后再看另外一种写法

static void Main(string[] args)
        {
            var watch1 = Stopwatch.StartNew();
            var watch2 = Stopwatch.StartNew();
            Console.WriteLine("Begin");
            var task = FooAsync();
            watch1.Stop();

            Console.WriteLine($"#耗时{watch1.ElapsedMilliseconds}");

            // Result的get方法会阻塞当前线程直到task执行完毕
            // 这个如果注释掉，那么FooAsync则只阻塞主线程2秒左右，如果不注释下面的代码，那么上面的FooAsync()会先阻塞主线程
            //Console.WriteLine(task.Result);
            watch2.Stop();

            Console.WriteLine($"耗时{watch2.ElapsedMilliseconds}");

            Console.WriteLine("End");
        }

        /**
         * 注意，Task是后台任务（由后台线程执行），而Java的Task，或者说Java默认的线程创建工厂创建的线程是前台线程（可配置）
         */
        static async Task<int> FooAsync()
        {
            Thread.Sleep(2000);  // 这一个会阻塞调用者
            Console.WriteLine($"{nameof(FooAsync)}方法先同步耗时2秒");
            // 这时候不能用int作为变量类型了
            var result = Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine($"{nameof(FooAsync)}方法耗时3秒执行完毕");
                return 8;
            });
            Thread.Sleep(2000);  // 重要，这一块不一定会阻塞调用方（await放在Task.Run那里）
            Console.WriteLine($"###{nameof(FooAsync)}方法先同步耗时2秒");
            // 注意，如果这个await放到上面的Task.Run(..)那里会令这一块的逻辑很奇怪，而且貌似执行是有问题的，都不知道它执行完毕没有
            return await result;
        }

　　其实仔细一比较，async和await是可以不需要的，用Task<TResult>就完全可以实现，只不过有部分写法会稍微麻烦一点点而已；await task;就可以用task.Result来代替；

async加await其实就是实现这样一个功能：

有async的方法，是在告诉编译器这个方法内部可能存在异步调用，如Task.Run(...);
然后内部对这个异步调用进行一个await（没有也行但是就失去了async和await带来的糖）；
这个糖的最重要的提现在于外部调用这个方法时，如这个方法叫FooAsync()，调用过程为：
var task = FooAsync();
如果接下来的代码没有类似task.Wait()或task.Result这样的等待操作，那么FooAsync()里面的异步部分对于调用者也是异步的（包括await后面的全部代码对于调用者都是异步的，这点很重要，如var result = await Task.Run(...);Thread.Sleep(2000);这个Sleep不会阻塞调用者）；

async/await其实是一种类似模板类的技术，有async且内部有await的方法是一种具备不同编译情况的方法（怎么编译要看怎么调用及使用具有async的方法，如调用者有task.Result是一种使用模式，没有task.Result或没有await task或task.Wait..之类的又是另一种模式）；

static void Main(string[] args)
        {
            // async/await其实是一种类似模板类的技术，有async且内部有await的方法是一种具备不同编译情况的方法；
            var watch1 = Stopwatch.StartNew();
            var watch2 = Stopwatch.StartNew();
            Console.WriteLine("Begin");
            var task = FooAsync();
            watch1.Stop();

            Console.WriteLine($"#耗时{watch1.ElapsedMilliseconds}");

            // Result的get方法会阻塞当前线程直到task执行完毕
            // 这个如果注释掉，那么FooAsync则只阻塞主线程2秒左右，如果不注释下面的代码，那么上面的FooAsync()会先阻塞主线程
            //Console.WriteLine(task.Result);
            watch2.Stop();

            Console.WriteLine($"耗时{watch2.ElapsedMilliseconds}");

            Console.WriteLine("End");
            // 这里可以通过输出End后立刻按回车或等几秒后按回车进行测试；
            Console.ReadKey();
        }

        /**
         * 注意，Task是后台任务（由后台线程执行），而Java的Task，或者说Java默认的线程创建工厂创建的线程是前台线程（可配置）
　　　　　 * 甚至编译器将FooAsync()方法编译成了FooAsync`1()和FooAsync`2()两个子方法，然后看调用者是否涉及到同步FooAsync方法结果的操作，有则编译器给调用方调用的是FooAsync`1()，没有则是用的FooAsync`2()方法
         */
        static async Task<int> FooAsync()
        {
            Thread.Sleep(2000);  // 这一个会阻塞调用者
            Console.WriteLine($"{nameof(FooAsync)}方法先同步耗时2秒");
            // 注意，await之后的所有代码是否阻塞调用者取决于调用者怎么用这个方法，如果调用者是await FooAsync()，那么这里之后的所有代码都是同步的
            // TODO 所以async和await和Task<TResult>相比多了一个类似开关一样的东西，但是这个开关是编译阶段确定的，有点像模板类用的时候必须给出具体的类型，而这里是具体的用法；
            // TODO 编译时如果调用者有task.Result之类的wait操作，那么【编译器】就将FooAsync整个当成一个同步方法，如果没有相关的操作，编译器就将这部分及其后面的代码作为异步方法处理【应该是通过闭包形成一个新的Task对象】
            // TODO 这里往下的代码，如果编译器发现调用方不需要同步，那么编译器底层是通过再开一个Task<int>将result和下面的Thread.Sleep(4000)等代码用闭包再包一层返回这个task对象；
            var result = await Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine($"{nameof(FooAsync)}方法耗时3秒执行完毕");
                return 8;
            });
            // TODO 注意，这一块是在上面的result执行完后才执行的，即上面先输出 FooAsync方法耗时3秒执行完毕 然后等待4秒后再输出 ###FooAsync方法先同步耗时4秒
            Thread.Sleep(4000);  // 重要，这一块不一定会阻塞调用方（await放在Task.Run那里），这一块是否阻塞调用者看调用者是否需要对返回的Task对象进行wait，且是编译时决定的；
            Console.WriteLine($"###{nameof(FooAsync)}方法先同步耗时4秒");
            // 注意，如果这个await放到上面的Task.Run(..)那里会令这一块的逻辑很奇怪，而且貌似执行是有问题的，都不知道它执行完毕没有
            return result;
        }

　　

来看进一步的测试：

static void Main(string[] args)
        {
            // async/await其实是一种类似模板类的技术，有async且内部有await的方法是一种具备不同编译情况的方法；
            var watch1 = Stopwatch.StartNew();
            var watch2 = Stopwatch.StartNew();
            Console.WriteLine($"Begin,threadId:{Thread.CurrentThread.ManagedThreadId}");
            var task = FooAsync();
            watch1.Stop();

            Console.WriteLine($"#耗时{watch1.ElapsedMilliseconds}");

            // Result的get方法会阻塞当前线程直到task执行完毕
            // 这个如果注释掉，那么FooAsync则只阻塞主线程2秒左右，如果不注释下面的代码，那么上面的FooAsync()会先阻塞主线程
            //Console.WriteLine(task.Result);  // TODO flagN
            watch2.Stop();

            Console.WriteLine($"耗时{watch2.ElapsedMilliseconds}");

            Console.WriteLine("End");
            // 这里可以通过输出End后立刻按回车或等几秒后按回车进行测试；
            Console.ReadKey();
        }

        /**
         * 注意，Task是后台任务（由后台线程执行），而Java的Task，或者说Java默认的线程创建工厂创建的线程是前台线程（可配置）
         */
        static async Task<int> FooAsync()
        {
            Thread.Sleep(2000);  // 这一个会阻塞调用者
            Console.WriteLine($"{nameof(FooAsync)}方法先同步耗时2秒");
            // 注意，await之后的所有代码是否阻塞调用者取决于调用者怎么用这个方法，如果调用者是await FooAsync()，那么这里之后的所有代码都是同步的
            // TODO 所以async和await和Task<TResult>相比多了一个类似开关一样的东西，但是这个开关是编译阶段确定的，有点像模板类用的时候必须给出具体的类型，而这里是具体的用法；
            // TODO 编译时如果调用者有task.Result之类的wait操作，那么【编译器】就将FooAsync整个当成一个同步方法，如果没有相关的操作，编译器就将这部分及其后面的代码作为异步方法处理【应该是通过闭包形成一个新的Task对象】
            // TODO 这里往下的代码，如果编译器发现调用方不需要同步，那么编译器底层是通过再开一个Task<int>将result和下面的Thread.Sleep(4000)等代码用闭包再包一层返回这个task对象；
            var result = await Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine($"{nameof(FooAsync)}方法耗时3秒执行完毕,threadId:{Thread.CurrentThread.ManagedThreadId}");
                return 8;
            });
            // TODO 注意，这一块是在上面的result执行完后才执行的，即上面先输出 FooAsync方法耗时3秒执行完毕 然后等待4秒后再输出 ###FooAsync方法先同步耗时4秒
            Thread.Sleep(4000);  // 重要，这一块不一定会阻塞调用方（await放在Task.Run那里），这一块是否阻塞调用者看调用者是否需要对返回的Task对象进行wait，且是编译时决定的；
            Console.WriteLine($"###{nameof(FooAsync)}方法先同步耗时4秒,threadIdNNN:{Thread.CurrentThread.ManagedThreadId}");
            return result;
        }

　　经过测试，flagN行无论是否注释，主线程的threadId和后面Task.Run及后面的threadIdNNN的线程id都是不同的，但是后面两个的线程id是一致的，因此编译器底层不是生成了FooAsync`1和FooAsync`2两个方法，而是将await及后面的代码合并为

一块，即FooAsync其实最终是变成这样子的代码（不一定百分百就是这个样子，但是可以解释测试结果）：

static async Task<int> FooAsync()
        {
            Thread.Sleep(2000);  // 这一个会阻塞调用者
            Console.WriteLine($"{nameof(FooAsync)}方法先同步耗时2秒");
            // 注意，await之后的所有代码是否阻塞调用者取决于调用者怎么用这个方法，如果调用者是await FooAsync()，那么这里之后的所有代码都是同步的
            // TODO 所以async和await和Task<TResult>相比多了一个类似开关一样的东西，但是这个开关是编译阶段确定的，有点像模板类用的时候必须给出具体的类型，而这里是具体的用法；
            // TODO 编译时如果调用者有task.Result之类的wait操作，那么【编译器】就将FooAsync整个当成一个同步方法，如果没有相关的操作，编译器就将这部分及其后面的代码作为异步方法处理【应该是通过闭包形成一个新的Task对象】
            // TODO 这里往下的代码，如果编译器发现调用方不需要同步，那么编译器底层是通过再开一个Task<int>将result和下面的Thread.Sleep(4000)等代码用闭包再包一层返回这个task对象；
            var result = Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine($"{nameof(FooAsync)}方法耗时3秒执行完毕,threadId:{Thread.CurrentThread.ManagedThreadId}");
                var tmp = 8;

                // TODO 注意，这一块是在上面的result执行完后才执行的，即上面先输出 FooAsync方法耗时3秒执行完毕 然后等待4秒后再输出 ###FooAsync方法先同步耗时4秒
                Thread.Sleep(4000);  // 重要，这一块不一定会阻塞调用方（await放在Task.Run那里），这一块是否阻塞调用者看调用者是否需要对返回的Task对象进行wait，且是编译时决定的；
                Console.WriteLine($"###{nameof(FooAsync)}方法先同步耗时4秒,threadIdNNN:{Thread.CurrentThread.ManagedThreadId}");

                return 8;
            });
            return result;
        }

　　这个result不会阻塞调用者；