Threadpool 可以对线程加以管理的封装

对线程的进一步加深：

//
        // 摘要:
        //     将方法排入队列以便执行。 此方法在有线程池线程变得可用时执行。
        //
        // 参数:
        //   callBack:
        //     一个 System.Threading.WaitCallback，表示要执行的方法。
        //
        // 返回结果:
        //     如果此方法成功排队，则为 true；如果无法将该工作项排队，则引发 System.NotSupportedException。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     callBack 为 null。
        //
        //   T:System.NotSupportedException:
        //     承载公共语言运行时 (CLR)，并且主机不支持此操作。
        [SecuritySafeCritical]
        public static bool QueueUserWorkItem(WaitCallback callBack);
        //
        // 摘要:
        //     将方法排入队列以便执行，并指定包含该方法所用数据的对象。 此方法在有线程池线程变得可用时执行。
        //
        // 参数:
        //   callBack:
        //     System.Threading.WaitCallback，它表示要执行的方法。
        //
        //   state:
        //     包含方法所用数据的对象。
        //
        // 返回结果:
        //     如果此方法成功排队，则为 true；如果无法将该工作项排队，则引发 System.NotSupportedException。
        //
        // 异常:
        //   T:System.NotSupportedException:
        //     承载公共语言运行时 (CLR)，并且主机不支持此操作。
        //
        //   T:System.ArgumentNullException:
        //     callBack 为 null。
        [SecuritySafeCritical]
        public static bool QueueUserWorkItem(WaitCallback callBack, object state);

#region PoolSet
            //ThreadPool.SetMaxThreads(8, 8);//最小也是核数
            //ThreadPool.SetMinThreads(8, 8);
            int workerThreads = 0;
            int ioThreads = 0;
            ThreadPool.GetMaxThreads(out workerThreads, out ioThreads);
            Console.WriteLine(String.Format("Max worker threads: {0};    Max I/O threads: {1}", workerThreads, ioThreads));

            ThreadPool.GetMinThreads(out workerThreads, out ioThreads);
            Console.WriteLine(String.Format("Min worker threads: {0};    Min I/O threads: {1}", workerThreads, ioThreads));

            ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);
            Console.WriteLine(String.Format("Available worker threads: {0};    Available I/O threads: {1}", workerThreads, ioThreads));
            #endregion

namespace System.Threading
{
    //
    // 摘要:
    //     通知一个或多个正在等待的线程已发生事件。 此类不能被继承。
    [ComVisible(true)]
    public sealed class ManualResetEvent : EventWaitHandle
    {
        //
        // 摘要:
        //     新实例初始化 System.Threading.ManualResetEvent 使用 Boolean 值，该值指示是否将初始状态设置为终止状态的类。
        //
        // 参数:
        //   initialState:
        //     true 若要设置的初始状态信号; false 初始状态设置为终止状态。
        public ManualResetEvent(bool initialState);
    }
}

线程池可以对多线程的调度加以管理，类似于操作系统里的知识。

1 信号量的理解

#region ManualResetEvent 信号量
            {
                ManualResetEvent mre = new ManualResetEvent(false);//false 关闭状态
                new Action(() =>
                {
                    Thread.Sleep(5000);
                    Console.WriteLine("委托的异步调用");
                    mre.Set();//打开状态
                }).BeginInvoke(null, null);

                mre.WaitOne();//等待打开信号量打开（申请资源）
                Console.WriteLine("12345");//打开后执行
                mre.Reset();//关闭（重置状态，回到初始状态）


                new Action(() =>
                {
                    Thread.Sleep(5000);
                    Console.WriteLine("委托的异步调用2");
                    mre.Set();//打开状态
                }).BeginInvoke(null, null);
                mre.WaitOne();
                Console.WriteLine("23456");
            }
            #endregion

2  ThreadPool.QueueUserWorkItem ---将方法排入队列以便执行。 此方法在有线程池线程变得可用时执行。

　　             ManualResetEvent mre = new ManualResetEvent(false);//信号量

                ThreadPool.QueueUserWorkItem(t =>
                {
                    this.DoSomethingLong("btnThreadPool_Click");
                    mre.Set(); 
                });
                mre.WaitOne();

//
        // 摘要:
        //     将事件状态设置为非终止，从而导致线程受阻。
        //
        // 返回结果:
        //     如果该操作成功，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ObjectDisposedException:
        //     之前已在此 System.Threading.EventWaitHandle 上调用 System.Threading.WaitHandle.Close
        //     方法。
        [SecuritySafeCritical]
        public bool Reset();
        //
        // 摘要:
        //     将事件状态设置为有信号，从而允许一个或多个等待线程继续执行。
        //
        // 返回结果:
        //     如果该操作成功，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ObjectDisposedException:
        //     之前已在此 System.Threading.EventWaitHandle 上调用 System.Threading.WaitHandle.Close
        //     方法。
        [SecuritySafeCritical]
        public bool Set();

        //
        // 摘要:
        //     阻止当前线程，直到当前 System.Threading.WaitHandle 收到信号。
        //
        // 返回结果:
        //     如果当前实例收到信号，则为 true。 如果当前实例永不发出信号，则 System.Threading.WaitHandle.WaitOne(System.Int32,System.Boolean)
        //     永不返回。
        //
        // 异常:
        //   T:System.ObjectDisposedException:
        //     当前实例已被释放。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     等待完成，因为线程退出时未释放互斥体。 在 Windows 98 或 Windows Millennium Edition 上不会引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     当前实例是透明代理 System.Threading.WaitHandle 另一个应用程序域中。
        public virtual bool WaitOne();

3. 整段代码在WinForm下的执行：

#region btnThreadPool_Click
        /// <summary>
        /// 2.0 线程池  享元模式   单例模式
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnThreadPool_Click(object sender, EventArgs e)
        {
            Console.WriteLine($"****************btnThreadPool_Click Start {Thread.CurrentThread.ManagedThreadId}***************");
            {
                ManualResetEvent mre = new ManualResetEvent(false);//信号量
                ThreadPool.QueueUserWorkItem(t =>
                {
                    this.DoSomethingLong("btnThreadPool_Click");
                    mre.Set();
                });
                mre.WaitOne();
            }

            #region ManualResetEvent
            {
                ManualResetEvent mre = new ManualResetEvent(false);//false 关闭
                new Action(() =>
                {
                    Thread.Sleep(5000);
                    Console.WriteLine("委托的异步调用");
                    mre.Set();//打开
                }).BeginInvoke(null, null);

                mre.WaitOne();
                Console.WriteLine("12345");
                mre.Reset();//关闭
                new Action(() =>
                {
                    Thread.Sleep(5000);
                    Console.WriteLine("委托的异步调用2");
                    mre.Set();//打开
                }).BeginInvoke(null, null);
                mre.WaitOne();
                Console.WriteLine("23456");
            }
            #endregion

            #region PoolSet
            ////ThreadPool.SetMaxThreads(8, 8);//最小也是核数
            ////ThreadPool.SetMinThreads(8, 8);
            //int workerThreads = 0;
            //int ioThreads = 0;
            //ThreadPool.GetMaxThreads(out workerThreads, out ioThreads);
            //Console.WriteLine(String.Format("Max worker threads: {0};    Max I/O threads: {1}", workerThreads, ioThreads));

            //ThreadPool.GetMinThreads(out workerThreads, out ioThreads);
            //Console.WriteLine(String.Format("Min worker threads: {0};    Min I/O threads: {1}", workerThreads, ioThreads));

            //ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);
            //Console.WriteLine(String.Format("Available worker threads: {0};    Available I/O threads: {1}", workerThreads, ioThreads));
            #endregion

            Console.WriteLine($"****************btnThreadPool_Click   End {Thread.CurrentThread.ManagedThreadId}***************");

        }
        #endregion