C# 温故而知新: 线程篇(二) 下

首先介绍下Classic Async Pattern:

其实Classic Async Pattern指的就是我们常见的BeginXXX和EndXXX

IAsyncResult 异步设计模式通过名为 BeginOperationName 和 EndOperationName 的两个方法来实现原同步方法的异步调用

让我们再来回顾下.net中的几个的BeginXXX 和EndXXX

Stream中的BeginRead,EndRead,BeginWrite,EndWriteSocket中的BeginReceive,EndReceiveHttpWebRequest的BeginGetRequestStream和EndGetRequestStream....

再来介绍下Event-based Async Pattern

Event-based Async Pattern 值的是类似于 xxxxxxxAsync() 和 类似于event xxxxxCompleteHander

通过一个方法和一个完成事件来处理异步操作

.net中的例子:

WebClient.DownloadStringAsync(string uri)和 event DownloadStringCompleteEventHandler

其实Classic Async Pattern和Event-based Async Pattern都是一种异步的设计思路,我们也可以根据这一系列的

思路去实现自己的异步方法

7 异步线程的发展趋势以及.net4.5中异步的简化

微软貌似现在把精力放在win8或WinPhone的metro上,而且记得在win 8开发者培训的会议上,着重阐述了微软对于异步的支持将越来越强,而且为了快

速响应诸如移动设备的应用程序,微软也在争取为每个方法都实现一个异步版本…..可见异步的重要性,相信异步的发展趋势是个不错的

上升曲线,还没反应过来.net4.5的异步新特性便诞生了。首先经历过异步摧残的我们,都会有这样一个感受,往往回调方法和普通方法

会搞错,在复杂的项目面前,有时候简直无法维护,到处都是回调函数,眼花缭乱 所以微软为了简化异步的实现过程,甚至大刀阔斧将

回调函数做成看起来像同步方法,虽然觉得很诡异,还是让我们初步了解下这种异步的新特性

先看代码

/// <summary>
        /// .net 4.5 中 async 和 await 全新的关键字 一起实现异步的简化
        /// </summary>
        void async ShowUriContent(string uri)
        {
            using (FileStream fs = File.OpenRead("你的文件地址"))
            {
                using (FileStream fs2 = new FileStream())
                {
                    byte[] buffer = new byte[4096];
                    //FileStream的ReadAsync方法也是net4.5版本出现的,它返回一个Task<int>对象
                    //而且作用于await后的异步代码会等待阻塞直到异步方法完成后返回
                    int fileBytesLength = await fs.ReadAsync(buffer,0,buffer.Length).ConfigureAwait(false);
                    while(fileBytesLength>0)
                    {
                           //FileStream的WriteAsync方法也是net4.5版本出现的
                           await fs2.WriteAsync(buffer,0,buffer.Length).ConfigureAwait(false);      
                    }             
                }
            }
        }

相信看完代码后大家有耳目一新的感觉,不错,原本异步调用的回调函数不见了,取而代之的是await和方法声明上的async关键字,新特性允许

我们实现这俩个关键字后便能在方法中实现“同步方式”的异步方法,其实这解决了一些棘手的问题,诸如原本需要在回调事件里才能释放的文件句

柄在这里和同步方法一样,使用using便搞定了,还有截获异常等等,都不用像之前那样痛苦了,这里还有一些东东需要关注下,大家先不用去深

究ConfigureAwait这个方法,由于ReadAsync和 WriteAsync方法是.net 4.5新加的属于返回Task<int>类型的方法所以使用ConfigureAwait

方法能够将数值取到,关于Task泛型类我会在今后的章节中详细阐述

8 本章示例

自定义一个简单的线程池

static void Main(string[] args)
        {
            ThreadStart[] startArray =
            {
              new ThreadStart(()=>{
                  Console.WriteLine("第一个任务"); 
              }),
              new ThreadStart(()=>{Console.WriteLine("第二个任务");}),
              new ThreadStart(()=>{Console.WriteLine("第三个任务");}),
              new ThreadStart(()=>{Console.WriteLine("第四个任务");}),
            };
            MyThreadPool.SetMaxWorkThreadCount(2);
            MyThreadPool.MyQueueUserWorkItem(startArray);
            Console.ReadKey();
        }


       /// <summary>
       /// 自定义一个简单的线程池,该线程池实现了默认开启线程数
       /// 当最大线程数全部在繁忙时,循环等待,只到至少一个线程空闲为止
       /// 本示例使用BackgroundWorker模拟后台线程,任务将自动进入队列和离开
       /// 队列
       /// </summary>
        sealed class MyThreadPool
        {
            //线程锁对象
            private static object lockObj = new object();
            //任务队列
            private static Queue<ThreadStart> threadStartQueue = new Queue<ThreadStart>();
            //记录当前工作的任务集合,从中可以判断当前工作线程使用数,如果使用int判断的话可能会有问题,
            //用集合的话还能取得对象的引用,比较好
            private static HashSet<ThreadStart> threadsWorker = new HashSet<ThreadStart>();
            //当前允许最大工作线程数
            private static int maxThreadWorkerCount = 1;
            //当前允许最小工作线程数
            private static int minThreadWorkerCount = 0;


            /// <summary>
            /// 设定最大工作线程数
            /// </summary>
            /// <param name="maxThreadCount">数量</param>
            public static void SetMaxWorkThreadCount(int maxThreadCount) 
            {
                maxThreadWorkerCount =minThreadWorkerCount>maxThreadCount?
                minThreadWorkerCount : maxThreadCount;
            }
            /// <summary>
            /// 设定最小工作线程数
            /// </summary>
            /// <param name="maxThreadCount">数量</param>
            public static void SetMinWorkThreadCount(int minThreadCount)
            {
                minThreadWorkerCount = minThreadCount > maxThreadWorkerCount ?
                maxThreadWorkerCount : minThreadCount;
            }
            /// <summary>
            /// 启动线程池工作
            /// </summary>
            /// <param name="threadStartArray">任务数组</param>
            public static void MyQueueUserWorkItem(ThreadStart[] threadStartArray)
            {
                //将任务集合都放入到线程池中
                AddAllThreadsToPool(threadStartArray);
                //线程池执行任务
                ExcuteTask();
            }
            /// <summary>
            /// 将单一任务加入队列中
            /// </summary>
            /// <param name="ts">单一任务对象</param>
            private static void AddThreadToQueue(ThreadStart ts)
            {
                lock (lockObj)
                {
                    threadStartQueue.Enqueue(ts);
                }
            }


            /// <summary>
            /// 将多个任务加入到线程池的任务队列中
            /// </summary>
            /// <param name="threadStartArray">多个任务</param>
            private static void AddAllThreadsToPool(ThreadStart[] threadStartArray)
            {
                foreach (var threadStart in threadStartArray)
                    AddThreadToQueue(threadStart);
            }


            /// <summary>
            /// 执行任务,判断队列中的任务数量是否大于0,如果是则判断当前正在使用的工作线程的
            /// 数量是否大于等于允许的最大工作线程数,如果一旦有线程空闲的话
            /// 就会执行ExcuteTaskInQueen方法处理任务
            /// </summary>
            private static void ExcuteTask()
            {
                while (threadStartQueue.Count > 0)
                {
                    if (threadsWorker.Count < maxThreadWorkerCount)
                    {
                        ExcuteTaskInQueen();
                    }
                }
            }


            /// <summary>
            /// 执行出对列的任务,加锁保护
            /// </summary>
            private static void ExcuteTaskInQueen()
            {
                lock (lockObj)
                {
                    ExcuteTaskByThread(
threadStartQueue.Dequeue());
                }
            }


            /// <summary>
            /// 实现细节,这里使用BackGroudWork来实现后台线程
            /// 注册doWork和Completed事件,当执行一个任务前,前将任务加入到
            /// 工作任务集合(表示工作线程少了一个空闲),一旦RunWorkerCompleted事件被触发则将任务从工作
            /// 任务集合中移除(表示工作线程也空闲了一个)
            /// </summary>
            /// <param name="threadStart"></param>
            private static void ExcuteTaskByThread(ThreadStart threadStart)
            {
                threadsWorker.Add(threadStart);
                BackgroundWorker worker = new BackgroundWorker();
                worker.DoWork += (o, e) => { threadStart.Invoke(); };
                worker.RunWorkerCompleted += (o, e) => { threadsWorker.Remove(threadStart); };
                worker.RunWorkerAsync();
            }
        }

显示结果:

Asp.net异步IHttpAsyncHandler示例

有时我们需要使用IHttpAsyncHandler来异步实现一些特定的功能,让我用很简单的示例来阐述这个过程

1:首先编写Handler1的逻辑,注意要继承IHttpAsyncHandler接口

/// <summary>
    /// 异步IHttpHandler,实现了一个简单的统计流量的功能,
    /// 由于是示例代码,所以没有判断IP或者MAC
    /// </summary>
    public class Handler1 : IHttpAsyncHandler
    {
        //默认访问量是0
        static int visitCount = 0;
        /// <summary>
        /// 这个HttpHandler的同步方法
        /// </summary>


        /// <param name="context"></param>
        public void ProcessRequest(HttpContext context)
        {
        }


        public bool IsReusable
        {
            get
            {
                return false;
            }
        }


        /// <summary>
        /// 实现IHttpAsyncHandler 接口方法
        /// </summary>
        /// <param name="context">当前HttpContext</param>
        /// <param name="cb">回调函数</param>
        /// <param name="extraData"></param>
        /// <returns></returns>
        public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
        {
            //这里可以加上判断IP或mac的方法
            visitCount++;
            //实例化AsyncUserVisiteCounterResult对象
            AsyncUserVisiteCounterResult result = new AsyncUserVisiteCounterResult(cb, visitCount, context);
            result.Display();
            return result;
        }


       /// <summary>
        ///  结束本次IHttpAsyncHandler工作时触发的request方法
       /// </summary>
       /// <param name="result"></param>
        public void EndProcessRequest(IAsyncResult result)
        {
 
        }
    }


    /// <summary>
    /// 自定义IAsyncResult 实现我们额外的Display方法
    /// </summary>
    public class AsyncUserVisiteCounterResult : IAsyncResult
    {
        //回调参数
        private object _param;
        //是否异步执行完成
        private bool _asyncIsComplete;
        //回调方法
        private AsyncCallback _callBack;
        //当前上下文
        private HttpContext _context;


        public AsyncUserVisiteCounterResult(AsyncCallback callBack, object stateParam, HttpContext context)
        {
            this._callBack = callBack;
            this._param = stateParam;
            _asyncIsComplete = false;
            this._context = context;
        }




        public object AsyncState
        {
            get { return this._param; }
        }


        /// <summary>
        /// 等待句柄用于同步功能,关于等待句柄会在后续章节陈述
/// </summary>
        public System.Threading.WaitHandle AsyncWaitHandle
        {
            get
            {
                return null;
            }
        }


        /// <summary>
        /// 该属性表示不需要异步任务同步完成
        /// </summary>
        public bool CompletedSynchronously
        {
            get { return false; }
        }
        /// <summary>
        /// 该属性表示异步任务是否已经执行完成
        /// </summary>
        public bool IsCompleted
        {
            get
            {
                return this._asyncIsComplete;
            }
        }


        /// <summary>
        /// 自定义的额外功能,需要注意的是,执行完异步功能后
        /// 要将_asyncIsComplete设置为true表示任务执行完毕而且
        /// 执行回调方法,否则异步工作无法结束页面会卡死
        /// </summary>
        public void Display()
        {
            //这里先不用waitHandle句柄来实现同步
            lock (this)
            {
                this._context.Response.Write("你是第" + (int)this._param + "位访问者,访问时间:"+DateTime.Now.ToString());
                this._asyncIsComplete = true;
                this._callBack(this);
            }
        }
    }

2 在web.config中添加相应的配置,注意path指的是.ashx所在的路径,指的是相应的文件类型

    <httpHandlers>
      <add verb="*" path="AsyncThreadInAsp.net.Handler1.ashx" type="AsyncThreadInAsp.net.Handler1"/>
    </httpHandlers>

3 最后在页面中访问

9 本章总结

本章详细介绍了CLR线程池和异步线程的一些概念和使用方法,包括线程池的优点和细节,异步的执行过程和重要元素等等,在下一章节中

原文发布于微信公众号 - 我为Net狂(dotNetCrazy)

原文发表时间:2016-07-01

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏小灰灰

Java 动手写爬虫: 二、 深度爬取

第二篇 前面实现了一个最基础的爬取单网页的爬虫,这一篇则着手解决深度爬取的问题 简单来讲,就是爬了一个网页之后,继续爬这个网页中的链接 1. 需求背景 背景...

64310
来自专栏郭霖

Android Volley完全解析(三),定制自己的Request

经过前面两篇文章的学习,我们已经掌握了Volley各种Request的使用方法,包括StringRequest、JsonRequest、ImageRequest...

2206
来自专栏IT技术精选文摘

ZooKeeper 分布式锁实现

1362
来自专栏XAI

微信企业号登录授权Java实现获取员工userid根据userid换openid

微信企业号登录授权Java实现获取员工userid根据userid换openid 2016年1月8日 为了方便测试 。debug 建议大家搞个花生壳或者其他的可...

8509
来自专栏逸鹏说道

c# 温故而知新: 线程篇(一) 下

Abort 方法: 其实 Abort 方法并没有像字面上的那么简单,释放并终止调用线程,其实当一个线程调用 Abort方法时,会在调用此方法的线程上引发一个异常...

2606
来自专栏hbbliyong

依赖注入(IOC)二

上一章我们讲了构造注入与设值注入,这一篇我们主要讲接口注入与特性注入。 接口注入 接口注入是将抽象类型的入口以方法定义在一个接口中,如果客户类型需要获得这个...

3487
来自专栏NetCore

一个让人遗忘的角落—Exception(二)

在上一篇中"一个被人遗忘的角落--Exception(一)"中,跟大家简单介绍了一下Exception,也使大家充分的了解了Exception管理在一个项目中的...

1889
来自专栏跟着阿笨一起玩NET

推荐一个CodeProject上的SlideForm控件

CodeProject有一篇文章介绍了怎么实现一个SlideForm,非常不错,收藏在此.

811
来自专栏圣杰的专栏

ABP入门系列(4)——创建应用服务

一、解释下应用服务层 应用服务用于将领域(业务)逻辑暴露给展现层。展现层通过传入DTO(数据传输对象)参数来调用应用服务,而应用服务通过领域对象来执行相应的业务...

2917
来自专栏NetCore

[原创]Fluent NHibernate之旅(四)-- 关系(中)

接着上一篇,我们继续讲解ORM中的关系。在数据库设计中,我们最多打交道的,要算一对多关系了,延续我们的示例,我们来讲解一下一对多的关系。 Fluent NHib...

20410

扫码关注云+社区