• 异步编程

    异步编程 In .NET

    2014-07-15 08:42 by Jesse Liu, 2909 阅读, 71 评论, 收藏, 编辑

    概述

    　　在之前写的一篇关于async和await的前世今生的文章之后，大家似乎在async和await提高网站处理能力方面还有一些疑问，博客园本身也做了不少的尝试。今天我们再来回答一下这个问题，同时我们会做一个async和await在WinForm中的尝试，并且对比在4.5之前的异步编程模式APM/EAP和async/await的区别，最后我们还会探讨在不同线程之间交互的问题。

    　　IIS存在着处理能力的问题，但是WinForm却是UI响应的问题，并且WinForm的UI线程至始至终都是同一个，所以两者之间有一定的区别。有人会问，现在还有人写WinForm吗？好吧，它确是一个比较老的东西呢，不如WPF炫，技术也不如WPF先进，但是从架构层面来讲，不管是Web，还是WinForm，又或是WPF，Mobile，这些都只是表现层，不是么？现在的大型系统一般桌面客户端，Web端，手机，平板端都会涉及，这也是为什么会有应用层，服务层的存在。我们在这谈论的ASP.NET MVC，WinForm，WFP，Android/IOS/WP 都是表现层，在表现层我们应该只处理与“表现”相关的逻辑，任何与业务相关的逻辑应该都是放在下层处理的。关于架构的问题，我们后面再慢慢深入，另外别说我没有提示您，我们今天还会看到.NET中另一个已经老去的技术Web Service。

    　　还得提示您，文章内容有点长，涉及的知识点比较多，所以，我推荐：”先顶后看“ ，先顶后看是21世纪看长篇的首选之道，是良好沟通的开端，想知道是什么会让你与众不同吗？想知道为什么上海今天会下这么大的雨么？请记住先顶后看，你顶的不是我的文章，而是我们冒着大雨还要去上班的可贵精神！先顶后看，你值得拥有！

    目录

    async/await如何提升IIS处理能力

    　　首先响应能力并不完全是说我们程序性能的问题，有时候可能你的程序没有任何问题，而且精心经过优化，可是响应能力还是没有上去，网站性能分析是一个复杂的活，有时候只能靠经验和不断的尝试才能达到比较好的效果。当然我们今天讨论的主要是IIS的处理能力，或者也可能说是IIS的性能，但绝非代码本身的性能。即使async/await能够提高IIS的处理能力，但是对于用户来说整个页面从发起请求到页面渲染完成的这些时间，是不会因为我们加了async/await之后产生多大变化的。

    　　另外异步的ASP.NET并非只有async/await才可以做的，ASP.NET在Web Form时代就已经有异步Page了，包括ASP.NET MVC不是也有异步的Controller么？async/await 很新，很酷，但是它也只是在原有一技术基础上做了一些改进，让程序员们写起异步代码来更容易了。大家常说微软喜欢新瓶装旧酒，至少我们要看到这个新瓶给我们带来了什么，不管是任何产品，都不可能一开始就很完美，所以不断的迭代更新，也可以说是一种正确做事的方式。

    ASP.NET并行处理的步骤

     　　ASP.NET是如何在IIS中工作的一文已经很详细的介绍了一个请求是如何从客户端到服务器的HTTP.SYS最后进入CLR进行处理的（强烈建议不了解这一块的同学先看这篇文章，有助于你理解本小节），但是所有的步骤都是基于一个线程的假设下进行的。IIS本身就是一个多线程的工作环境，如果我们从多线程的视角来看会发生什么变化呢？我们首先来看一下下面这张图。注意：我们下面的步骤是建立在IIS7.0以后的集成模式基础之上的。

    　　我们再来梳理一下上面的步骤：

    1. 所有的请求最开始是由HTTP.SYS接收的，HTTP.SYS内部有一个队列维护着这些请求，这个队列的request的数量大于一定数量（默认是1000）的时候，HTTP.SYS就会直接返回503状态（服务器忙），这是我们的第一个阀门。
    2. HTTP.SYS把请求交给CLR 线程池中的IO线程
    3. CLR 线程池中的 Worker线程从IO线程中接过请求来处理，IO线程不必等待该请求的处理结果，而是可以返回继续去处理HTTP.SYS队列中的请求。IO线程和Worker线程的数量上限是第二个阀门。
    4. 当CLR中正在被处理的请求数据大于一定值（最大并行处理请求数量）的时候，从IO线程过来的请求就不会直接交给Worker线程，而是放到一个进程池级别的一个队列了，等到这个数量小于临界值的时候，才会把它再次交给Worker线程去处理。这是我们的第三个阀门。

     哪些因素会控制我们的响应能力

    　　从上面我们提到了几大阀门中，我们可以得出下面的几个数字控制或者说影响着我们的响应能力。

    1. HTTP.SYS队列的长度
    2. 最大IO线程数量和最大Worker线程数量
    3. 最大并行处理请求数量

    HTTP.SYS队列的长度

    　　这个我觉得不需要额外解释，默认值是1000。这个值取决于我们我们后面CLR IO线程和Worker线程的处理速度，如果它们两个都处理不了，这个数字再大也没有用。因为最后他们会被存储到进程池级别的队列中，所以只会造成内存的浪费。

    最大IO线程数量和最大Worker线程数量

    　　这两个值是可以在web.config中进行配置的。

    　　maxIoThreads: 从HTTP.SYS队列中拿请求的最大IO线程数量
    　　maxWorkerThreads: CLR中真实处理请求的最大Worker线程数量
    　　minIoThreads: 从HTTP.SYS队列中拿请求的最小IO线程数量
    　　minWorkerThreads:CLR中真实处理请求的最小Worker线程数量

    　　minIoThreads和minWorkerThreads的默认值是1，合理的加大他们可以避免不必要的线程创建和销毁工作。maxIoThreads如果设置太大的话，或者说不合理的话就会导致多数的request被放到进程池级别的队列中。所以 maxIoThreads和maxWorkerThreads是有一定关系的，假设1个worker线程1s可以处理10个请求，如果我们的机器配置只允许我们同时处理100个请求，那我们合理的maxThreads就是10。但是IO线程并不需要10s去处理一个请求，它比woker线程快，因为它只要从HTTP.SYS的队列那里拿过来就可以了，我们假设一个IO线程1s可以处理20个请求，对应100个请求的上限，那我们maxIoThreads的合理值应该是5。

    最大并行处理请求数量

    　　进程池级别的队列给我们的CLR一定的缓冲，这里面要注意的是，这个队列还没有进入到CLR，所以它不会占用我们托管环境的任何资源，也就是把请求卡在了CLR的外面。我们需要在aspnet.config级别进行配置，我们可以在.net fraemwork的安装目录下找到它。一般是 C:WindowsMicrosoft.NETFrameworkv4.0.30319 如果你安装的是4.0的话。

    　　maxConcurrentRequestPerCPU: 每个CPU所允许的最大并行处理请求数量，当CLR中worker线程正在处理的请求之和大于这个数时，从IO线程过来的请求就会被放到我们进程池级别的队列中。
    　　maxConcurrentThreadsPerCPU: 设置为0即禁用。
    　　requestQueueLimit：这个就是我们HTTP.SYS中队列的那个长度，我们可以在web.config/system.web/processModel结点下配置。

    async和await 做了什么？

    　　我们终于要切入正题了，拿ASP.NET MVC举例，如果不采用async的Action，那么毫无疑问，它是在一个Woker线程中执行的。当我们访问一些web service，或者读文件的时候，这个Worker线程就会被阻塞。假设我们这个Action执行时间一共是100ms，其它访问web service花了80ms，理想情况下一个Worker线程一秒可以响应10个请求，假设我们的maxWorkerThreads是10，那我们一秒内总是可响应请求就是100。如果说我们想把这个可响应请求数升到200怎么做呢？

    　　有人会说，这还不简单，把maxWorkerThreads调20不就行了么？ 其实我们做也没有什么 问题，确实是可以的，而且也确实能起到作用。那我们为什么还要大费周章的搞什么 async/await呢？搞得脑子都晕了？async/await给我们解决了什么问题？它可以在我们访问web service的时候把当前的worker线程放走，将它放回线程池，这样它就可以去处理其它的请求了。和IO线程一样，IO线程只负责把请求交给Worker线程或者放入进程池级别的队列，然后又去HTTP.SYS的队列中处理其它的请求。等到web service给我们返回结果了，会再到线程池中随机拿一个新的woker线程继续往下执行。也就是说我们减少了那一部分等待的时间，充份利用了线程。

    　   我们来对比一下使用async/awit和不使用的情况，

    　　不使用async/await： 20个woker线程1s可以处理200个请求。

    　　那转换成总的时间的就是 20 * 1000ms =  20000ms，
    　　其中等待的时间为 200 * 80ms = 16000ms。
    　　也就是说使用async/await我们至少节约了16000ms的时间，这20个worker线程又会再去处理请求，即使按照每个请求100ms的处理时间我们还可以再增加160个请求。而且别忘了100ms是基于同步情况下，包括等待时间在内的基础上得到的，所以实际情况可能还要多，当然我们这里没有算上线程切换的时间，所以实际情况中是有一点差异的，但是应该不会很大，因为我们的线程都是基于线程池的操作。
    　　所有结果是20个Worker线程不使用异步的情况下，1s能自理200个请求，而使用异步的情况下可以处理360个请求，立马提升80%呀！采用异步之后，对于同样的请求数量，需要的Worker线程数据会大大减少50%左右，一个线程至少会在堆上分配1M的内存，如果是1000个线程那就是1G的容量，虽然内存现在便宜，但是省着总结是好的嘛，而且更少的线程是可以减少线程池在维护线程时产生的CPU消耗的。

    　　注意：以上数据并非真实测试数据，真实情况一个request的时间也并非100ms，花费在web service上的时间也并非80ms，仅仅是给大家一个思路:)，所以这里面用了async和await之后对响应能力有多大的提升和我们原来堵塞在这些IO和网络上的时间是有很大的关系的。

    几点建议

    　　看到这里，不知道大家有没有得到点什么。首先第一点我们要知道的是async/await不是万能药，不们不能指望光写两个光键字就希望性能的提升。要记住，一个CPU在同一时间段内是只能执行一个线程的。所以这也是为什么async和await建议在IO或者是网络操作的时候使用。我们的MVC站点访问WCF或者Web Service这种场景就非常的适合使用异步来操作。在上面的例子中80ms读取web service的时间，大部份时间都是不需要cpu操作的，这样cpu才可以被其它的线程利用，如果不是一个读取web service的操作，而是一个复杂计算的操作，那你就等着cpu爆表吧。

    　　第二点是，除了程序中利用异步，我们上面讲到的关于IIS的配置是很重要的，如果使用了异步，请记得把maxWorkerThreads和maxConcurrentRequestPerCPU的值调高试试。

     早期对Web service的异步编程模式APM

    　　讲完我们高大上的async/await之后，我们来看看这个技术很老，但是概念确依旧延续至今的Web Service。 我们这里所说的针对web service的异步编程模式不是指在服务器端的web service本身，而是指调用web service的客户端。大家知道对于web service，我们通过添加web service引用或者.net提供的生成工具就可以生成相应的代理类，可以让我们像调用本地代码一样访问web service，而所生成的代码类中对针对每一个web service方法生成3个对应的方法，比如说我们的方法名叫DownloadContent，除了这个方法之外还有BeginDownloadContent和EndDownloadContent方法，而这两个就是我们今天要说的早期的异步编程模式APM(Asynchronous Programming Model)。下面就来看看我们web service中的代码，注意我们现在的项目都是在.NET Framework3.5下实现的。

     PageContent.asmx的代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class PageContent : System.Web.Services.WebService
    {
        [WebMethod]
        public string DownloadContent(string url)
        {
            var client = new System.Net.WebClient();
            return client.DownloadString(url);
        }
    }

    　　注意我们web service中的DownloadContent方法调用的是WebClient的同步方法，WebClient也有异步方法即：DownloadStringAsync。但是大家要明白，不管服务器是同步还是异步，对于客户端来说调用了你这个web service都是一样的，就是得等你返回结果。

    　　当然，我们也可以像MVC里面的代码一样，把我们的服务器端也写成异步的。那得到好处的是那个托管web service的服务器，它的处理能力得到提高，就像ASP.NET一样。如果我们用JavaScript去调用这个Web Service，那么Ajax(Asynchronous Javascript + XML)就是我们客户端用到的异步编程技术。如果是其它的客户端呢？比如说一个CS的桌面程序？我们需要异步编程么？

    当WinForm遇上Web Service

    　　WinForm不像托管在IIS的ASP.NET网站，会有一个线程池管理着多个线程来处理用户的请求，换个说法ASP.NET网站生来就是基于多线程的。但是，在WinForm中，如果我们不刻意使用多线程，那至始至终，都只有一个线程，称之为UI线程。也许在一些小型的系统中WinForm很少涉及到多线程，因为WinForm本身的优势就在它是独立运行在客户端的，在性能上和可操作性上都会有很大的优势。所以很多中小型的WinForm系统都是直接就访问数据库了，并且基本上也只有数据的传输，什么图片资源那是很少的，所以等待的时间是很短的，基本不用费什么脑力去考虑什么3秒之内必须将页面显示到用户面前这种问题。

    　　既然WinForm在性能上有这么大的优势，那它还需要异步吗？

    　　我们上面说的是中小型的WinForm，如果是大型的系统呢？如果WinForm只是其它的很小一部分，就像我们文章开始说的还有很多其它成千上万个手机客户端，Web客户端，平板客户端呢？如果客户端很多导致数据库撑不住怎么办？ 想在中间加一层缓存怎么办？

    　　拿一个b2b的网站功能举例，用户可以通过网站下单，手机也可以下单，还可以通过电脑的桌面客户端下单。在下完单之后要完成交易，库存扣减，发送订单确认通知等等功能，而不管你的订单是通过哪个端完成的，这些功能我们都要去做，对吗？那我们就不能单独放在WinForm里面了，不然这些代码在其它的端里面又得全部全新再一一实现，同样的代码放在不同的地方那可是相当危险的，所以就有了我们后来的SOA架构，把这些功能都抽成服务，每种类型的端都是调用服务就可以了。一是可以统一维护这些功能，二是可以很方便的做扩展，去更好的适应功能和架构上的扩展。比如说像下面这样的一个系统。

     

    　　在上图中，Web端虽然也是属于我们平常说的服务端（甚至是由多台服务器组成的web群集），但是对我们整个系统来说，它也只是一个端而已。对于一个端来说，它本身只处理和用户交互的问题，其余所有的功能，业务都会交给后来台处理。在我们上面的架构中，应用层都不会直接参加真正业务逻辑相关的处理，而是放到我们更下层数据层去做处理。那么应用层主要协助做一些与用户交互的一些功能，如果手机短信发送，邮件发送等等，并且可以根据优先级选择是放入队列中稍候处理还是直接调用功能服务立即处理。

    　　在这样的一个系统中，我们的Web服务器也好，Winform端也好都将只是整个系统中的一个终端，它们主要的任何是用户和后面服务之间的一个桥梁。涉及到Service的调用之后，为了给用户良好的用户体验，在WinForm端，我们自然就要考虑异步的问题。 

    WinForm异步调用Web Service

    　　有了像VS这样强大的工具为我们生成代理类，我们在写调用Web service的代码时就可以像调用本地类库一样调用Web Service了，我们只需要添加一个Web Reference就可以了。

    // Form1.cs的代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    private void button1_Click(object sender, EventArgs e)
    {
        var pageContentService = new localhost.PageContent();
        pageContentService.BeginDownloadContent(
            "http://jesse2013.cnblogs.com",
            new AsyncCallback(DownloadContentCallback),
            pageContentService);
    }
     
    private void DownloadContentCallback(IAsyncResult result)
    {
        var pageContentService = (localhost.PageContent)result.AsyncState;
        var msg = pageContentService.EndDownloadContent(result);
        MessageBox.Show(msg);
    }

    　　代码非常的简单，在执行完pageContentService.BeginDownloadContent之后，我们的主线程就返回了。在调用Web service这段时间内我们的UI不会被阻塞，也不会出现“无法响应这种情况”，我们依然可以拖动窗体甚至做其它的事情。这就是APM的魔力，但是我们的callback究竟是在哪个线程中执行的呢？是线程池中的线程么？咋们接着往下看。

    APM异步编程模式详解

    线程问题

    　　接下来我们就是更进一步的了解APM这种模式是如何工作的，但是首先我们要回答上面留下来的问题，这种异步的编程方式有没有为我们开启新的线程？让代码说话：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    private void button1_Click(object sender, EventArgs e)
    {
        Trace.TraceInformation("Is current thread from thread pool? {0}", Thread.CurrentThread.IsThreadPoolThread ? "Yes" : "No");
        Trace.TraceInformation("Start calling web service on thread: {0}", Thread.CurrentThread.ManagedThreadId);
        var pageContentService = new localhost.PageContent();
        pageContentService.BeginDownloadContent(
            "http://jesse2013.cnblogs.com",
            new AsyncCallback(DownloadContentCallback),
            pageContentService);
    }
     
    private void DownloadContentCallback(IAsyncResult result)
    {
        var pageContentService = (localhost.PageContent)result.AsyncState;
        var msg = pageContentService.EndDownloadContent(result);
     
        Trace.TraceInformation("Is current thread from thread pool? {0}" , Thread.CurrentThread.IsThreadPoolThread ? "Yes" : "No");
        Trace.TraceInformation("End calling web service on thread: {0}, the result of the web service is: {1}",
            Thread.CurrentThread.ManagedThreadId,
            msg);
    }

    　　我们在按钮点击的方法和callback方法中分别输出当前线程的ID，以及他们是否属于线程池的线程，得到的结果如下：

    　　Desktop4.0.vshost.exe Information: 0 : Is current thread a background thread? NO
    　　Desktop4.0.vshost.exe Information: 0 : Is current thread from thread pool? NO
    　　Desktop4.0.vshost.exe Information: 0 : Start calling web service on thread: 9
    　　Desktop4.0.vshost.exe Information: 0 : Is current thread a background thread? YES
    　　Desktop4.0.vshost.exe Information: 0 : Is current thread from thread pool? YES
    　　Desktop4.0.vshost.exe Information: 0 : End calling web service on thread: 14, the result of the web service is: <!DOCTYPE html>...

    　　按钮点击的方法是由UI直接控制，很明显它不是一个线程池线程，也不是后台线程。而我们的callback却是在一个来自于线程池的后台线程执行的，答案揭晓了，可是这会给我们带来一个问题，我们上面讲了只有UI线程也可以去更新我们的UI控件，也就是说在callback中我们是不能更新UI控件的，那我们如何让更新UI让用户知道反馈呢？答案在后面接晓 :)，让我们先专注于把APM弄清楚。

    从Delegate开始

    　　其实，APM在.NET3.5以前都被广泛使用，在WinForm窗体控制中，在一个IO操作的类库中等等！大家可以很容易的找到搭配了Begin和End的方法，更重要的是只要是有代理的地方，我们都可以使用APM这种模式。我们来看一个很简单的例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    delegate void EatAsync(string food);
    private void button2_Click(object sender, EventArgs e)
    {
        var myAsync = new EatAsync(eat);
        Trace.TraceInformation("Activate eating on thread: {0}", Thread.CurrentThread.ManagedThreadId);
        myAsync.BeginInvoke("icecream", new AsyncCallback(clean), myAsync);
    }
     
    private void eat(string food)
    {
        Trace.TraceInformation("I am eating.... on thread: {0}", Thread.CurrentThread.ManagedThreadId);
    }
     
    private void clean(IAsyncResult asyncResult)
    {
        Trace.TraceInformation("I am done eating.... on thread: {0}", Thread.CurrentThread.ManagedThreadId);
    }

    　　上面的代码中，我们通过把eat封装成一个委托，然后再调用该委托的BeginInvoke方法实现了异步的执行。也就是实际的eat方法不是在主线程中执行的，我们可以看输出的结果：

    　　Desktop4.0.vshost.exe Information: 0 : Activate eating on thread: 10
    　　Desktop4.0.vshost.exe Information: 0 : I am eating.... on thread: 6
    　　Desktop4.0.vshost.exe Information: 0 : I am done eating.... on thread: 6

    　　clean是我们传进去的callback，该方法会在我们的eat方法执行完之后被调用，所以它会和我们eat方法在同一个线程中被调用。大家如果熟悉代理的话就会知道，代码实际上会被编译成一个类，而BeginInvoke和EndInvoke方法正是编译器为我们自动加进去的方法，我们不用额外做任何事情，这在早期没有TPL和async/await之前（APM从.NET1.0时代就有了），的确是一个不错的选择。

    再次认识APM

    了解了Delegate实现的BeginInvoke和EndInvoke之后，我们再来分析一下APM用到的那些对象。 拿我们Web service的代理类来举例，它为我们生成了以下3个方法：

    1. string DownloadContent(string url)： 同步方法
    2. IAsyncResult BeginDownloadContent(string url, AsyncCallback callback, object asyncState)： 异步开始方法
    3. EndDownloadContent(IAsyncResult asyncResult)：异步结束方法

    　　在我们调用EndDownloadContent方法的时候，如果我们的web service调用还没有返回，那这个时候就会用阻塞的方式去拿结果。但是在我们传到BeginDownloadContent中的callback被调用的时候，那操作一定是已经完成了，也就是说IAsyncResult.IsCompleted = true。而在APM异步编程模式中Begin方法总是返回IAsyncResult这个接口的实现。IAsyncReuslt仅仅包含以下4个属性：

    　　WaitHanlde通常作为同步对象的基类，并且可以利用它来阻塞线程，更多信息可以参考MSDN 。 借助于IAsyncResult的帮助，我们就可以通过以下几种方式去获取当同所执行操作的结果。

    1. 轮询
    2. 强制等待
    3. 完成通知

    　　完成通知就是们上面用到的那种，调完Begin方法之后，主线程就算完成任务了。我们也不用监控该操作的执行情况，当该操作执行完之后，我们在Begin方法中传进去的callback就会被调用了，我们可以在那个方法中调用End方法去获取结果。下面我们再简单说一下前面两种方式。

    //轮询获取结果代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    var pageContentService = new localhost.PageContent();
    IAsyncResult asyncResult = pageContentService.BeginDownloadContent(
        "http://jesse2013.cnblogs.com",
        null,
        pageContentService);
     
    while (!asyncResult.IsCompleted)
    {
        Thread.Sleep(100);
    }
    var content = pageContentService.EndDownloadContent(asyncResult);

     // 强制等待结果代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    var pageContentService = new localhost.PageContent();
    IAsyncResult asyncResult = pageContentService.BeginDownloadContent(
        "http://jesse2013.cnblogs.com",
        null,
        pageContentService);
     
    // 也可以调用WaitOne()的无参版本，不限制强制等待时间
    if (asyncResult.AsyncWaitHandle.WaitOne(2000))
    {
        var content = pageContentService.EndDownloadContent(asyncResult);
    }
    else
    {
        // 2s时间已经过了，但是还没有执行完  
    }

    EAP(Event-Based Asynchronous Pattern)

    　　EAP是在.NET2.0推出的另一种过渡的异步编程模型，也是在.NET3.5以后Microsoft支持的一种做法，为什么呢？ 如果大家建一个.NET4.0或者更高版本的WinForm项目，再去添加Web Reference就会发现生成的代理类中已经没有Begin和End方法了，记住在3.5的时候是两者共存的，你可以选择任意一种来使用。但是到了.NET4.0以后，EAP成为了你唯一的选择。（我没有尝试过手动生成代理类，有兴趣的同学可以尝试一下）让我们来看一下在.NET4下，我们是如何异步调用Web Service的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    private void button1_Click(object sender, EventArgs e)
    {
        var pageContent = new localhost.PageContent();
        pageContent.DownloadContentAsync("http://jesse2013.cnblogs.com");
        pageContent.DownloadContentCompleted += pageContent_DownloadContentCompleted;
    }
     
    private void pageContent_DownloadContentCompleted(object sender, localhost.DownloadContentCompletedEventArgs e)
    {
        if (e.Error == null)
        {
            textBox1.Text = e.Result;
        }
        else
        {
            // 出错了
        }
    }

    线程问题

    　　不知道大家还是否记得，在APM模式中，callback是执行在另一个线程中，不能随易的去更新UI。但是如果你仔细看一下上面的代码，我们的DownloadContentCompleted事件绑定的方法中直接就更新了UI，把返回的内容写到了一个文本框里面。通过同样的方法可以发现，在EAP这种异步编程模式下，事件绑定的方法也是在调用的那个线程中执行的。也就是说解决了异步编程的时候UI交互的问题，而且是在同一个线程中执行。 看看下面的代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    private void button1_Click(object sender, EventArgs e)
    {
        Trace.TraceInformation("Call DownloadContentAsync on thread: {0}", Thread.CurrentThread.ManagedThreadId);
        Trace.TraceInformation("Is current from thread pool? : {0}", Thread.CurrentThread.IsThreadPoolThread ? "YES": "NO");
     
        var pageContent = new localhost.PageContent();
        pageContent.DownloadContentAsync("http://jesse2013.cnblogs.com");
        pageContent.DownloadContentCompleted += pageContent_DownloadContentCompleted;
    }
     
    private void pageContent_DownloadContentCompleted(object sender, localhost.DownloadContentCompletedEventArgs e)
    {
        Trace.TraceInformation("Completed DownloadContentAsync on thread: {0}", Thread.CurrentThread.ManagedThreadId);
        Trace.TraceInformation("Is current from thread pool? : {0}", Thread.CurrentThread.IsThreadPoolThread ? "YES": "NO");
    }

    　　Desktop4.vshost.exe Information: 0 : Call DownloadContentAsync on thread: 10
    　　Desktop4.vshost.exe Information: 0 : Is current from thread pool? : NO
    　　Desktop4.vshost.exe Information: 0 : Completed DownloadContentAsync on thread: 10
    　　Desktop4.vshost.exe Information: 0 : Is current from thread pool? : NO

    async/await 给WinFrom带来了什么

    　　如果说async给ASP.NET带来的是处理能力的提高，那么在WinForm中给程序员带来的好处则是最大的。我们再也不用因为要实现异步写回调或者绑定事件了，省事了，可读性也提高了。不信你看下面我们将调用我们那个web service的代码在.NET4.5下实现一下：

    1
    2
    3
    4
    5
    6
    7
    private async void button2_Click(object sender, EventArgs e)
    {
        var pageContent = new localhost.PageContentSoapClient();
        var content = await pageContent.DownloadContentAsync("http://jesse2013.cnblogs.com");
     
        textBox1.Text = content.Body.DownloadContentResult;
    }

    　　简单的三行代码，像写同步代码一样写异步代码，我想也许这就是async/await的魔力吧。在await之后，UI线程就可以回去响应UI了，在上面的代码中我们是没有新线程产生的，和EAP一样拿到结果直接就可以对UI操作了。

    　　async/await似乎真的很好，但是如果我们await后面的代码执行在另外一个线程中会发生什么事情呢？

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    private async void button1_Click(object sender, EventArgs e)
    {
        label1.Text = "Calculating Sqrt of 5000000";
        button1.Enabled = false;
        progressBar1.Visible = true;
     
        double sqrt = await Task<double>.Run(() =>
        {
            double result = 0;
            for (int i = 0; i < 50000000; i++)
            {
                result += Math.Sqrt(i);
     
                progressBar1.Maximum = 50000000;
                progressBar1.Value = i;
            }
            return result;
        });
     
        progressBar1.Visible = false;
        button1.Enabled = true;
        label1.Text = "The sqrt of 50000000 is " + sqrt;
    }

    　　我们在界面中放了一个ProgressBar，同时开一个线程去把从1到5000000的平方全部加起来，看起来是一个非常耗时的操作，于是我们用Task.Run开了一个新的线程去执行。（注：如果是纯运算的操作，多线程操作对性能没有多大帮助，我们这里主要是想给UI一个进度显示当前进行到哪一步了。）看起来没有什么问题，我们按F5运行吧！
    　　Bomb~

    　　当执行到这里的时候，程序就崩溃了，告诉我们”无效操作，只能从创建porgressBar的线程访问它。“  这也是我们一开始提到的，在WinForm程序中，只有UI主线程才能对UI进行操作，其它的线程是没有权限的。接下来我们就来看看，如果在WinForm中实现非UI线程对UI控制的更新操作。 

    不同线程之间通讯的问题

    万能的Invoke

    　　WinForm中绝大多数的控件包括窗体在内都实现了Invoke方法，可以传入一个Delegate，这个Delegate将会被拥有那个控制的线程所调用，从而避免了跨线程访问的问题。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    Trace.TraceInformation("UI Thread : {0}", Thread.CurrentThread.ManagedThreadId);
    double sqrt = await Task<double>.Run(() =>
    {
        Trace.TraceInformation("Run calculation on thread: {0}", Thread.CurrentThread.ManagedThreadId);
        double result = 0;
        for (int i = 0; i < 50000000; i++)
        {
            result += Math.Sqrt(i);
            progressBar1.Invoke(new Action(() => {
                Trace.TraceInformation("Update UI on thread: {0}", Thread.CurrentThread.ManagedThreadId);
                progressBar1.Maximum = 50000000;
                progressBar1.Value = i;
            }));
        }
        return result;
    });

    　　Desktop.vshost.exe Information: 0 : UI Thread : 9
    　　Desktop.vshost.exe Information: 0 : Run calculation on thread: 10
    　　Desktop.vshost.exe Information: 0 : Update UI on thread: 9

    　　Invoke方法比较简单，我们就不做过多的研究了，但是我们要考虑到一点，Invoke是WinForm实现的UI同交互技术，WPF用的却是Dispatcher，如果是在ASP.NET下跨线程之间的同步又怎么办呢。为了兼容各种技术平台下，跨线程同步的问题，Microsoft在.NET2.0的时候就引入了我们下面的这个对象。

    SynchronizationContext上下文同步对象

    为什么需要SynchronizationContext

    　　就像我们在WinForm中遇到的问题一样，有时候我们需要在一个线程中传递一些数据或者做一些操作到另一个线程。但是在绝大多数情况下这是不允许的，出于安全因素的考虑，每一个线程都有它独立的内存空间和上下文。因此在.NET2.0，微软推出了SynchronizationContext。

    　　它主要的功能之一是为我们提供了一种将一些工作任务（Delegate)以队列的方式存储在一个上下文对象中，然后把这些上下文对象关联到具体的线程上，当然有时候多个线程也可以关联到同一个SynchronizationContext对象。获取当前线程的同步上下文对象可以使用SynchronizationContext.Current。同时它还为我们提供以下两个方法Post和Send，分别是以异步和同步的方法将我们上面说的工作任务放到我们SynchronizationContext的队列中。

    SynchronizationContext示例

    　　还是拿我们上面Invoke中用到的例子举例，只是这次我们不直接调用控件的Invoke方法去更新它，而是写了一个Report的方法专门去更新UI。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    double sqrt = await Task<double>.Run(() =>
    {
        Trace.TraceInformation("Current thread id is:{0}", Thread.CurrentThread.ManagedThreadId);
     
        double result = 0;
        for (int i = 0; i < 50000000; i++)
        {
            result += Math.Sqrt(i);
            Report(new Tuple<int, int>(50000000, i));
        }
        return result;
    });

    　　每一次操作完之后我们调用一下Report方法，把我们总共要算的数字，以前当前正在计算的数字传给它就可以了。接下来就看我们的Report方法了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    private SynchronizationContext m_SynchronizationContext;
    private DateTime m_PreviousTime = DateTime.Now;
     
    public Form1()
    {
        InitializeComponent();
        // 在全局保存当前UI线程的SynchronizationContext对象
        m_SynchronizationContext = SynchronizationContext.Current;
    }
     
    public void Report(Tuple<int, int> value)
    {
        DateTime now = DateTime.Now;
        if ((now - m_PreviousTime).Milliseconds > 100)
        {
            m_SynchronizationContext.Post((obj) =>
            {
                Tuple<int, int> minMax = (Tuple<int, int>)obj;
                progressBar1.Maximum = minMax.Item1;
                progressBar1.Value = minMax.Item2;
            }, value);
     
            m_PreviousTime = now;
        }
    }

    　　整个操作看起来要比Inovke复杂一点，与Invoke不同的是SynchronizationContext不需要对Control的引用，而Invoke必须先得有那个控件才能调用它的Invoke方法去更新它。

    小结

    　　这篇博客内容有点长，不知道有多少人可以看到这里:)。最开始我只是想写写WinFrom下异步调用Web Service的一些东西，在我开始这篇文件的题目是”异步编程在WinForm下的实践“，但是写着写着发现越来越多的迷团没有解开，其实都是一些老的技术以前没有接触和掌握好，所以所幸就一次性把他们都重新学习了一遍，与大家分享。

    　　我们再来回顾一下文章所涉及到的一些重要的概念：

    1. async/await 在ASP.NET做的最大贡献（早期ASP.NET的异步开发模式同样也有这样的贡献），是在访问数据库的时候、访问远程IO的时候及时释放了当前的处理性程，可以让这些线程回到线程池中，从而实现可以去处理其它请求的功能。
    2. 异步的ASP.NET开发能够在处理能力上带来多大的提高，取决于我们的程序有多少时间是被阻塞的，也就是那些访问数据库和远程Service的时间。
    3. 除了将代码改成异步，我们还需要在IIS上做一些相对的配置来实现最优化。
    4. 不管是ASP.NET、WinForm还是Mobile、还是平板，在大型系统中都只是一个与用户交互的端而已，所以不管你现在是做所谓的前端（JavaScript + CSS等)，还是所谓的后端(ASP.NET MVC、WCF、Web API 等 )，又或者是比较时髦的移动端（IOS也好，Andrioid也罢，哪怕是不争气的WP），都只是整个大型系统中的零星一角而已。当然我并不是贬低这些端的价值，正是因为我们专注于不同，努力提高每一个端的用户体验，才能让这些大型系统有露脸的机会。我想说的是，在你对现在技术取得一定的成就之后，不要停止学习，因为整个软件架构体系中还有很多很多美妙的东西值得我们去发现。
    5. APM和EAP是在async/await之前的两种不同的异步编程模式。
    6. APM如果不阻塞主线程，那么完成通知（回调）就会执行在另外一个线程中，从而给我们更新UI带来一定的问题。
    7. EAP的通知事件是在主线程中执行的，不会存在UI交互的问题。
    8. 最后，我们还学习了在Winform下不同线程之间交互的问题，以及SynchronizationContext。
    9. APM是.NET下最早的异步编程方法，从.NET1.0以来就有了。在.NET2.0的时候，微软意识到了APM的回调函数中与UI交互的问题，于是带来了新的EAP。APM与EAP一直共存到.NET3.5，在.NET4.0的时候微软带来了TPL，也就是我们所熟知的Task编程，而.NET4.5就是我们大家知道的async/await了，可以看到.NET一直在不停的进步，加上最近不断的和开源社区的合作，跨平台等特性的引入，我们有理由相信.NET会越走越好。

    　　最后，这篇文章从找资料学习到写出来，差不多花了我两个周未的时间，希望能够给需要的人或者感兴趣想要不断学习的人一点帮助（不管是往前学习，还是往后学习）。 

    引用 & 扩展阅读

    http://blogs.msdn.com/b/tmarq/archive/2010/04/14/performing-asynchronous-work-or-tasks-in-asp-net-applications.aspx
    http://blog.stevensanderson.com/2008/04/05/improve-scalability-in-aspnet-mvc-using-asynchronous-requests
    http://blogs.msdn.com/b/tmarq/archive/2007/07/21/asp-net-thread-usage-on-iis-7-0-and-6-0.aspx 
    http://blogs.msdn.com/b/tmarq/archive/2010/04/14/performing-asynchronous-work-or-tasks-in-asp-net-applications.aspx
    http://mohamadhalabi.com/2014/05/08/thread-throttling-in-iis-hosted-wcf-sync-vs-async/
    Pro Asynchronous Programs with .NET by Richard Blewett and Andrew Clymer

    作者：Jesse 出处： http://jesse2013.cnblogs.com/
  • 相关阅读:
    测开之路九十九：js函数、事件、window窗体对象
    测开之路九十八：js变量和语句
    测开之路九十七：js的引用方式
    学生管理之登录实现
    学生管理之表单设计
    二、Django用户认证之cookie和session
    一、Django前后端交互之Ajax和跨域问题
    中间介
    Java SE之反射技术[Class](三)
    Java SE之反射技术[Field](二)
  • 原文地址：https://www.cnblogs.com/Leo_wl/p/3845402.html
Copyright © 2020-2023  润新知