async & await 的前世今生

最新推荐文章于 2018-03-11 09:50:00 发布
最新推荐文章于 2018-03-11 09:50:00 发布
阅读量411 收藏 1
点赞数
分类专栏： C# - 多线程

原文：async & await 的前世今生

1. 铺垫基础知识：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp4
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("1. 创建");
            Create();
            Console.WriteLine("2. 线程池");
            ThreadPoolTest();
            Console.WriteLine("3. 传入参数");
            ParaTest();
            Console.WriteLine("4. 返回值");
            ReturnTest();
            Console.WriteLine("5. Semaphore 信号量(锁很好理解，忽视)");
            SemaphoreSlimTest();
            Console.WriteLine("6. 异常");
            //ThreadExceptionTest();
            //TaskExceptionTest();

            Console.Read();
        }

        public static void TaskExceptionTest()
        {
            try
            {
                var task = Task.Run(() => { GoException(); });
                task.Wait();  // 在调用了这句话之后，主线程才能捕获task里面的异常

                // 对于有返回值的Task, 我们接收了它的返回值就不需要再调用Wait方法了
                // GetName 里面的异常我们也可以捕获到
                var task2 = Task.Run(() => { GetNameExeception(); });
                task2.Wait();
                //var name = task2.Result;
            }
            catch (AggregateException ex)
            {
                foreach(Exception ex2 in ex.InnerExceptions)
                Console.WriteLine("Exception!{0}", ex2.Message);
            }
        }

        private static void GetNameExeception()
        {
            throw new Exception("Task Exeception.");
        }

        public static void ThreadExceptionTest()
        {
            try
            {
                new Thread(GoException).Start();
            }
            catch (Exception ex)
            {
                // 其它线程里面的异常，我们这里面是捕获不到的。
                Console.WriteLine("Thread Exception!");
            }
        }
        static void GoException() { throw new Exception("Go Exception"); }


        static SemaphoreSlim _sem = new SemaphoreSlim(3);    // 我们限制能同时访问的线程数量是3
        static void SemaphoreSlimTest()
        {
            for (int i = 1; i <= 5; i++)
            {
                new Thread(Enter).Start(i);
            }
        }

        static void Enter(object id)
        {
            Console.WriteLine(id + " 开始排队...");
            _sem.Wait();
            Console.WriteLine("{0} 开始执行！, 将允许进入 SemaphoreSlim 线程数: {1}", id, _sem.CurrentCount);
            Thread.Sleep(1000 * (int)id);
            Console.WriteLine(id + " 执行完毕，离开！");
            _sem.Release();
        }

        static void ReturnTest()
        {
            // GetDayOfThisWeek 运行在另外一个线程中
            var dayName = Task.Run<string>(() => { return GetDayOfThisWeek(); });
            Console.WriteLine("今天是：{0}", dayName.Result);
        }

        private static string GetDayOfThisWeek()
        {
            return DateTime.Now.DayOfWeek.ToString();
        }

        private static void ParaTest()
        {
            new Thread(Go2).Start("arg1"); // 没有匿名委托之前，我们只能这样传入一个object的参数

            new Thread(delegate ()
            {  // 有了匿名委托之后...
                GoGoGo("arg1", "arg2", "arg3");
            }).Start();

            new Thread(() =>
            {  // 当然,还有 Lambada
                GoGoGo("arg1", "arg2", "arg3");
            }).Start();

            Task.Run(() =>
            {  // Task能这么灵活，也是因为有了Lambda呀。
                GoGoGo("arg1", "arg2", "arg3");
            });
        }

        public static void GoGoGo(string arg1, string arg2, string arg3)
        {
            Console.WriteLine("1.{0}; 2.{1}; 3.{2}",arg1,arg2,arg3);
        }

        private static void ThreadPoolTest()
        {
            Console.WriteLine("我是主线程：Thread Id {0}", Thread.CurrentThread.ManagedThreadId);
            ThreadPool.QueueUserWorkItem(Go2);
        }

        public static void Go2(object data)
        {
            Console.WriteLine("我是另一个线程:Thread Id {0}, 参数值：{1}"
                , Thread.CurrentThread.ManagedThreadId
                , data
                );
        }

        private static void Create()
        {
            new Thread(Go).Start();  // .NET 1.0开始就有的
            Task.Factory.StartNew(Go); // .NET 4.0 引入了 TPL
            Task.Run(new Action(Go)); // .NET 4.5 新增了一个Run的方法
        }

        public static void Go()
        {
            Console.WriteLine("我是另一个线程");
        }
    }
}

2.  一个小例子认识async & await 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp5
{
    class Program
    {
        static void Main(string[] args)
        {
            Test(); // 这个方法其实是多余的, 本来可以直接写下面的方法
                    // await GetName() 
                    // 但是由于控制台的入口方法不支持async,所有我们在入口方法里面不能 用 await

            Console.WriteLine("Current Thread Id :{0}", Thread.CurrentThread.ManagedThreadId);
            Console.Read();
        }

        static async Task Test()
        {
            // 方法打上async关键字，就可以用await调用同样打上async的方法
            //  await 之后不会开启新的线程(await 从来不会开启新的线程)
            await GetName();
        }

        static async Task GetName()
        {
            // Delay 方法来自于.net 4.5
            await Task.Delay(1000);  // 返回值前面加 async 之后，方法里面就可以用await了
            Console.WriteLine("Current Thread Id :{0}", Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine("In antoher thread.....");
        }
    }
}

3. 看清什么时候才创建线程： 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main Thread Id: {0}\r\n", Thread.CurrentThread.ManagedThreadId);
            Test();
            Console.ReadLine();
        }

        static async Task Test()
        {
            Console.WriteLine("Before calling GetName, Thread Id: {0}\r\n", Thread.CurrentThread.ManagedThreadId);
            var name = GetName();   //我们这里没有用 await,所以下面的代码可以继续执行
                                    // 但是如果上面是 await GetName()，下面的代码就不会立即执行，输出结果就不一样了。
            Console.WriteLine("End calling GetName.\r\n");
            Console.WriteLine("Get result from GetName: {0}", await name);
            Console.WriteLine("end.");
        }

        static async Task<string> GetName()
        {
            // 这里还是主线程
            Console.WriteLine("Before calling Task.Run, current thread Id is: {0}", Thread.CurrentThread.ManagedThreadId);
            return await Task.Run(() =>
            {
                Thread.Sleep(1000);
                Console.WriteLine("'GetName' Thread Id: {0}", Thread.CurrentThread.ManagedThreadId);
                return "Jesse";
            });
        }
    }
}





不用 await 关键字， 如何确认Task已执行完？

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {
        static void Main()
        {
            var task = Task.Run(() => {
                return GetName();
            });

            task.GetAwaiter().OnCompleted(() => {
                // 2 秒之后才会执行这里
                var name = task.Result;
                Console.WriteLine("My name is: " + name);
            });

            Console.WriteLine("主线程执行完毕");
            Console.ReadLine();
        }

        static string GetName()
        {
            Console.WriteLine("另外一个线程在获取名称");
            Thread.Sleep(2000);
            return "Jesse";
        }
    }
}


Task 如何让线程挂起？

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {
        static void Main()
        {
            var task = Task.Run(() => {
                return GetName();
            });

            var name = task.GetAwaiter().GetResult();
            Console.WriteLine("My name is:{0}", name);

            Console.WriteLine("主线程执行完毕");
            Console.ReadLine();
        }

        static string GetName()
        {
            Console.WriteLine("另外一个线程在获取名称");
            Thread.Sleep(2000);
            return "Jesse";
        }
    }
}


Task.GetAwait()方法会给我们返回一个awaitable的对象，通过调用这个对象的GetResult方法就会挂起主线程，当然也不是所有的情况都会挂起。还记得我们Task的特性么？ 在一开始的时候就启动了另一个线程去执行这个Task，当我们调用它的结果的时候如果这个Task已经执行完毕，主线程是不用等待可以直接拿其结果的，如果没有执行完毕那主线程就得挂起等待了。

await 实质是在调用awaitable对象的GetResult方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {
        static void Main()
        {
            Test();
            Console.ReadLine();
        }

        static async Task Test()
        {
            Task<string> task = Task.Run(() => {
                Console.WriteLine("另一个线程在运行！");  // 这句话只会被执行一次
                Thread.Sleep(2000);
                return "Hello World";
            });

            // 这里主线程会挂起等待，直到task执行完毕我们拿到返回结果
            var result = task.GetAwaiter().GetResult();
            Console.WriteLine(result);
            // 这里不会挂起等待，因为task已经执行完了，我们可以直接拿到结果
            var result2 = await task;
            Console.WriteLine(result2);
        }
    }
}


吉普赛的歌
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
理解Koa2中的async&await的用法
08-28
"理解Koa2中的async&await的用法" 了解Koa2中的async&await的用法非常重要，因为Koa2框架的核心是基于async/await的异步编程模型的。_async_和_await_是JavaScript中两种非常重要的异步编程关键字，它们可以帮助...
js代码-async&await
07-16
`async/await`是ES2017引入的一种新的异步编程解决方案，它为Promise链式调用提供了一种更简洁、更易于理解的写法。在本主题中，我们将深入探讨`async/await`的工作原理、优势以及如何在实际项目中应用。 `async`...
转:async & await 的前世今生 ; 异步 线程 多线程
02-24 62
写的非常好,改天搬过来 转载于:https://www.cnblogs.com/joeylee/p/3565094.html
Async & Await 的前世今生
weixin_30511039的博客
03-11 76
Async 和 Await 出现在C# 5.0之后，给并行编程带来了不少的方便，特别是当在MVC中的Action也变成async之后，有点开始什么都是async的味道了。 但是这也给我们编程埋下了一些隐患，有时候可能会产生一些我们自己都不知道怎么产生的Bug，特别是如果连线程基础没有理解的情况下，更不知道如何去处理了。 那今天我们就来好好看看这两兄弟和他们的叔叔（Task）爷爷(T...
Js中async/await的执行顺序详解
10-19
随着async/await正式纳入ES7标准，越来越多的人开始研究据说是异步编程终级解决方案的 async/await。下面这篇文章主要给大家介绍了关于Js中async/await执行顺序的相关资料，需要的朋友可以参考借鉴，下面来一起看看...
浅谈C#中的Async和Await的用法详解
12-31
众所周知C#提供Async和Await关键字来实现异步编程。在本文中，我们将共同探讨并介绍什么是Async 和 Await，以及如何在C#中使用Async 和 Await。 同样本文的内容也大多是翻译的，只不过加上了自己的理解进行了相关...
ASP.NET 谨用 async/await
10-18
【ASP.NET 中慎用 async/await】\n\n在 ASP.NET 开发中，async/await 关键字的引入，使得异步编程变得更加简洁。然而，实际应用中，如果不小心，可能会遇到一系列问题，如异常捕获困难、死锁以及应用程序崩溃。本文...
说说C#的async和await的具体用法
08-29
C# async 和 await 的具体用法 C# 5.0 中引入了 async 和 await 两个关键字，这两个关键字可以让开发者更方便地编写异步代码。async 和 await 的出现使得异步编程变得更加简单易懂。 async 关键字 async 关键字...
async和await用法介绍
01-13
async和await用法
关于async和await的一些误区实例详解
09-04
async和await是C#编程中用于实现异步编程的关键特性，它们经常被误解，尤其是在与多线程和并发处理的概念混淆时。本文将通过实例详细解释这些常见的误区，帮助开发者更深入地理解C#程序设计。 首先，我们要明确...
vue如何使用async、await实现同步请求
10-15
在Vue.js应用中，使用`async/await`语法可以极大地简化异步操作，尤其是处理多个API请求时。`async/await`是ES2017引入的特性，它允许我们将异步代码写得像同步代码一样，使得代码更加可读和易于理解。下面将详细...
async/await异步处理demo
06-27
`async/await`是ES2017引入的一种更优雅、更易读的异步编程方式，它极大地改善了传统的回调函数和Promise链式调用的复杂性。下面我们将深入探讨`async/await`的原理、用法以及如何在实际项目中应用。 `async`关键字...
Promise Async+await实现原理及案例分析
04-03
Promise Async+await实现原理及案例分析
ea-async：EA Async在JVM中实现async-await方法
02-03
EA Async在JVM中实现Async-Await方法。 它允许程序员以顺序的方式编写异步代码。 它在很大程度上受到.NET CLR上Async-Await的启发，有关更多信息，请参见进行。 谁应该使用它？ 应该使用EA Async编写非阻塞异步...
详解C#中的Async和Await用法
09-03
在C#编程中，`async`和`await`是用于实现异步编程的关键特性，它们在C# 5.0及以后的版本中引入，伴随着.NET Framework 4.5和Visual Studio 2012。异步编程允许程序在等待耗时操作（如网络I/O或数据库查询）时，不...
ES7之Async/await的使用详解
10-17
ES6引入的Promise解决了这一问题，而ES7的Async/Await则进一步优化了Promise的使用体验，使得异步代码更接近同步的写法。 首先，我们需要了解Promise。Promise是一个代表未来某个时刻可能完成或失败的操作的对象。...
C#关键字async/await用法
12-23
经过一番的探索，终于搞清楚关键字async/await 在.net4.5之后可用的巧妙之处，在这里记录一下也与大家分享一下个人的心得体会 async：异步执行 await：异步执行中的等待其执行完(最大的优点是它是后台等待，因此不...
深入理解ES7的async/await的用法
08-29
深入理解ES7的async/await用法 ES7的async/await是解决JavaScript异步编程的重要概念，它能够使得异步代码更易读、更易维护。本文将深入探讨async/await的用法，并与Promise和co模块进行比较。 1. async/await是...
async&await的用法是什么？
最新发布
04-12
async和await是Python中用于异步编程的关键字。它们的用法如下[^1][^2]： 1. async关键字用于定义一个异步函数，即一个可以被中断和恢复执行的函数。异步函数在执行过程中可以暂停，等待其他任务完成后再继续执行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值