线程池和异步线程

using System;
using System.Threading;

namespace ThreadPoolApplication
{
    class Program
    {
        //设定任务数量 
        static int count = 5;
        static void Main(string[] args)
        {
            //关于ManualResetEvent大伙不必深究，兴许章将会具体阐述，这里因为如果
            //让线程池运行5个任务所以也为每一个任务加上这个对象保持同步
            ManualResetEvent[] events=new ManualResetEvent[count];
            Console.WriteLine("当前主线程id:{0}",Thread.CurrentThread.ManagedThreadId);
            //循环每一个任务
            for (int i = 0; i < count; i++)
            {
                //实例化同步工具
                events[i]=new ManualResetEvent(false);
                //Test在这里就是任务类。将同步工具的引用传入能保证共享区内每次仅仅有一个线程进入
                Test tst = new Test(events[i]);
                Thread.Sleep(1000);
                //将任务放入线程池中，让线程池中的线程运行该任务
                ThreadPool.QueueUserWorkItem(tst.DisplayNumber, new { num1=2});
            }
            //注意这里，设定WaitAll是为了堵塞调用线程（主线程）。让其余线程先运行完成，
            //当中每一个任务完成后调用其set()方法(收到信号),当全部
            //的任务都收到信号后。运行完成，将控制权再次交回调用线程（这里的主线程）
            ManualResetEvent.WaitAll(events);
           
            Console.ReadKey();
        }
    }

    public class Test 
    {
        ManualResetEvent manualEvent;
        public Test(ManualResetEvent manualEvent) 
        {
            this.manualEvent = manualEvent;
        }
        public void DisplayNumber(object a) 
        {
            Console.WriteLine("当前运算结果:{0}",((dynamic)a).num1);
            Console.WriteLine("当前子线程id:{0} 的状态:{1}", Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.ThreadState);
            //这里是方法运行时间的模拟，如果凝视该行代码，就能看出线程池的功能了
            //Thread.Sleep(30000);
            //这里是释放共享锁，让其它线程进入
            manualEvent.Set();
        }
    }
}

        //定义一个托付
        public delegate void DoSomething();
        static void Main(string[] args)
        {
            //1.实例化一个托付，调用者发送一个请求，请求运行该方法体（还未运行）
            DoSomething doSomething = new DoSomething(
                () => 
                { 
                    Console.WriteLine("假设托付使用beginInvoke的话，这里便是异步方法体");
                    //4。实现完这种方法体后自己主动触发以下的回调函数方法体
                });
            //3 。调用者（主线程）去触发异步调用，採用异步的方式请求上面的方法体
           IAsyncResult result= doSomething.BeginInvoke(
                //2.自己定义上面方法体运行后的回调函数
                new AsyncCallback
                    (
                    //5.以下是回调函数方法体
                     //asyncResult.AsyncState事实上就是AsyncCallback托付中的第二个參数
                       asyncResult => {
                           doSomething.EndInvoke(asyncResult);
                           Console.WriteLine(asyncResult.AsyncState.ToString()); 
                       }
                    )
                , "BeginInvoke方法的第二个參数就是传入AsyncCallback中的AsyncResult.AsyncState,我们使用时能够强转成相关类型加以使用");
            //DoSomething......调用者（主线程）会去做自己的事情
            Console.ReadKey();
        }

    /// <summary>
        /// .net 4.5 中 async 和 await 全新的keyword 一起实现异步的简化
        /// </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);      
                    }             
                }
            }
        }

        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();
            }
        }

    /// <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);
            }
        }



    }

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