C多线程（三） -- CLR线程池的工作者线程

1. 关于CLR线程池

使用ThreadStart与ParameterizedThreadStart建立新线程非常简单，但通过此方法建立的线程难于管理，若建立过多的线程反而会影响系统的性能

所以，

.NET

引入

CLR

线程池这个概念。CLR线程池并不会在CLR初始化的时候立刻建立线程，而是在应用程序要创建线程来执行任务时，线程池才初始化一个线程。线程的初始化与其他的线程一样。在完成任务以后，该线程不会自行销毁，而是以挂起的状态返回到线程池。直到应用程序再次向线程池发出请求时，线程池里挂起的线程就会再度激活执行任务。

这样既节省了建立线程所造成的性能损耗，也可以让多个任务反复重用同一线程，从而在应用程序生存期内节约大量开销

注意：通过CLR线程池所建立的线程总是默认为后台线程，优先级数为ThreadPriority.Normal

2. 工作者线程与I/O线程

CLR线程池分为工作者线程（workerThreads）与 I/O线程 (completionPortThreads) 两种

工作者线程是主要用作管理 CLR 内部对象的运作
I/O（Input/Output) 线程顾名思义是用于与外部系统交换信息

3. API

// 获取可以同时处于活动状态的线程池请求的最大数目。所有大于此数目的请求将保持排队状态，直到线程池线程变为可用
ThreadPool.GetMaxThreads();
//函数原型：
public static void GetMaxThreads (out int workerThreads,out int completionPortThreads)
    参数1：workerThreads ：线程池中辅助线程的最大数目。 
    参数2：completionPortThreads ：线程池中异步 I/O 线程的最大数目

//获取线程池维护的空闲线程数
ThreadPool.GetMinThreads();
//函数原型：
public static void GetMinThreads (out int workerThreads,out int completionPortThreads)
    参数1：workerThreads：当前由线程池维护的空闲辅助线程的最小数目。 
    参数2：completionPortThreads：当前由线程池维护的空闲异步 I/O 线程的最小数目

//  获取由 GetMaxThreads 返回的线程池线程的最大数目和当前活动数目之间的差值。
GetAvailableThreads()       
//函数原型：
public static void GetAvailableThreads (out int workerThreads,out int completionPortThreads)
     参数1：workerThreads：可用辅助线程的数目。 
     参数2：completionPortThreads：可用异步 I/O 线程的数目

//将方法排入队列以便执行。此方法在有线程池线程变得可用时执行 
QueueUserWorkItem()   
//重载方法1：
public static bool QueueUserWorkItem (WaitCallback callBack)
             返回值：如果将方法成功排入队列，则为 true；否则为 false。 
//重载方法2：
public static bool QueueUserWorkItem (WaitCallback callBack,Object state)
             参数2：state ：包含方法所用数据的对象。 
             返回值：如果将方法成功排入队列，则为 true；否则为 false。 

备注：WaitCallback 回调方法必须与System.Threading.WaitCallback委托类型相匹配。WaitCallback函数原型：public delegate void WaitCallback(Object state);
调用QueueUserWorkItem可以通过Object来向任务过程传递参数。如果任务过程需要多个参数，可以定义包含这些数据的类，并将类的实例强制转换为Object数据类型

Framework2.0 中最大线程默认为25*CPU数，在Framewok3.0、4.0中最大线程数默认为250*CPU数

默认最大线程数量 = 处理器数 * 250

默认最小线程数 = 处理器数

代码验证给你看看：

0;
            int j = 0;
            //前面是辅助(也就是所谓的工作者)线程，后面是I/O线程
            ThreadPool.GetMaxThreads(out i, out j);
            Console.WriteLine(i.ToString() + "   " + j.ToString()); //默认都是1000

            //获取空闲线程，由于现在没有使用异步线程，所以为空
            ThreadPool.GetAvailableThreads(out i, out j);
            Console.WriteLine(i.ToString() + "   " + j.ToString()); //默认都是1000

            Console.ReadKey();

4. 使用 CLR 工作者线程

使用CLR线程池的工作者线程一般有两种方式

一：ThreadPool.QueueUserWorkItem() 方法
二：通过委托

5. 通过QueueUserWorkItem启动工作者线程

//ThreadPool线程池中包含有两个静态方法可以直接启动工作者线程：

ThreadPool.QueueUserWorkItem(WaitCallback)
ThreadPool.QueueUserWorkItem(WaitCallback,Object)

先把WaitCallback委托指向一个带有Object参数的无返回值方法，再使用 ThreadPool.QueueUserWorkItem(WaitCallback) 就可以异步启动此方法，此时异步方法的参数被视为null

class Program
        //显示线程现状
        static void ThreadMessage(string data)
        {
            string message = string.Format("{0}\n  CurrentThreadId is {1}",
                 data, Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(message);
            //Console.WriteLine("data = " + data);
        }

        static void AsyncCallback(object state)
        {
            Thread.Sleep(200);
            ThreadMessage("AsyncCallback");
            Console.WriteLine("Async thread do work!");
        }

        static void Main(string[] args)
        {
            //把CLR线程池的最大值设置为1000
            ThreadPool.SetMaxThreads(1000, 1000);
            //显示主线程启动时线程池信息
            ThreadMessage("Start");
            //启动工作者线程
            ThreadPool.QueueUserWorkItem(new

使用 ThreadPool.QueueUserWorkItem(WaitCallback,Object) 方法可以把object对象作为参数传送到回调函数中。

下面例子中就是把一个string对象作为参数发送到回调函数当中

class Program
        static void Main(string[] args)
        {
            //把线程池的最大值设置为1000
            ThreadPool.SetMaxThreads(1000, 1000);

            ThreadMessage("Start");
            //第二个参数 -- AsyncCallback(object state)
            ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncCallback), "Hello York");
            Console.ReadKey();
        }

        static void AsyncCallback(object state)
        {
            Thread.Sleep(200);
            ThreadMessage("AsyncCallback");

            string data = (string)state;
            Console.WriteLine("Async thread do work!\n" + data);
        }

        //显示线程现状
        static void ThreadMessage(string data)
        {
            string message = string.Format("{0}\n  CurrentThreadId is {1}",
                 data, Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(message);
        }
    }

通过ThreadPool.QueueUserWorkItem启动工作者线程虽然是方便，但WaitCallback委托指向的必须是一个带有Object参数的无返回值方法，这无疑是一种限制。若方法需要有返回值，或者带有多个参数，这将多费周折。所以，.NET提供了另一种方式去建立工作者线程，那就是委托

5. 委托类　

使用CLR线程池中的工作者线程，最灵活最常用的方式就是使用委托的异步方法，在此先简单介绍一下委托类。

当定义委托后，.NET就会自动创建一个代表该委托的类，下面可以用反射方式显示委托类的方法成员

class Program
    {
        delegate void MyDelegate();

        static void Main(string[] args)
        {
            MyDelegate delegate1 = new MyDelegate(AsyncThread);
            //显示委托类的几个方法成员     
            var methods=delegate1.GetType().GetMethods();
            if (methods != null)
                foreach (MethodInfo info in methods)
                    Console.WriteLine(info.Name);
            Console.ReadKey();
         }
     }

public class MyDelegate:MulticastDelegate
    {
        public MyDelegate(object target, int methodPtr);
        //调用委托方法
        public virtual void Invoke();
        //异步委托
        public virtual IAsyncResult BeginInvoke(AsyncCallback callback,object state);
        public virtual void EndInvoke(IAsyncResult result);
    }

当调用Invoke（）方法时，对应此委托的所有方法都会被执行。而BeginInvoke与EndInvoke则支持委托方法的异步调用，由BeginInvoke启动的线程都属于CLR线程池中的工作者线程

6. 利用BeginInvoke与EndInvoke完成异步委托方法

首先建立一个委托对象，通过IAsyncResult BeginInvoke(string name,AsyncCallback callback,object state) 异步调用委托方法，BeginInvoke 方法除最后的两个参数外，其它参数都是与方法参数相对应的。通过 BeginInvoke 方法将返回一个实现了 System.IAsyncResult 接口的对象，之后就可以利用EndInvoke（IAsyncResult ) 方法就可以结束异步操作，获取委托的运行结果

/// <summary>
    /// 1.委托(需要异步调用的方法) -->
    ///
    /// 3.异步方法完成后，接受结果 -->
    /// </summary>
    class Program
    {
        delegate string MyDelegate(string name);

        static void Main(string[] args)
        {
            ThreadMessage("Main Thread");

            //建立委托
            MyDelegate myDelegate = new MyDelegate(Hello);
            //异步调用委托，获取计算结果
            IAsyncResult result = myDelegate.BeginInvoke("Leslie", null, null);
            //完成主线程其他工作
           // ............. 
            //等待异步方法完成，调用EndInvoke(IAsyncResult)获取运行结果
            string data = myDelegate.EndInvoke(result);
            Console.WriteLine("Async method completed --> "+ data);

            Console.ReadKey();
        }

        static string Hello(string name)
        {
            ThreadMessage("Async Thread");
            Thread.Sleep(2000);            //虚拟异步工作
            return "Hello " + name;
        }

        //显示当前线程message
        static void ThreadMessage(string data)
        {
            string message = string.Format("{0}\n  ThreadId is:{1}",
                   data, Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(message);
        }
    }

7. 善用IAsyncResult

如果在使用myDelegate.BeginInvoke后立即调用myDelegate.EndInvoke，那在异步线程未完成工作以前主线程将处于阻塞状态，等到异步线程结束获取计算结果后，主线程才能继续工作，这明显无法展示出多线程的优势。此时可以好好利用IAsyncResult 提高主线程的工作性能，IAsyncResult有以下成员：

public interface IAsyncResult
{
    object AsyncState {get;}            //获取用户定义的对象，它限定或包含关于异步操作的信息。
    WailHandle AsyncWaitHandle {get;}   //获取用于等待异步操作完成的 WaitHandle。
    bool CompletedSynchronously {get;}  //获取异步操作是否同步完成的指示。
    bool IsCompleted {get;}             //获取异步操作是否已完成的指示。

过轮询方式，使用IsCompleted属性判断异步操作是否完成，这样在异步操作未完成前就可以让主线程执行另外的工作

class Program
    {
        delegate string MyDelegate(string name);

        static void Main(string[] args)
        {
            ThreadMessage("Main Thread");

            //建立委托
            MyDelegate myDelegate = new MyDelegate(Hello);
            //异步调用委托，获取计算结果
            IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);
            //在异步线程未完成前执行其他工作
            while (!result.IsCompleted)
            {
                Thread.Sleep(200);      //虚拟操作
                Console.WriteLine("Main thead do work!");
            }
            string data=myDelegate.EndInvoke(result);
            Console.WriteLine(data);

            Console.ReadKey();
        }

        static string Hello(string name)
        {
            ThreadMessage("Async Thread");
            Thread.Sleep(2000);
            return "Hello " + name;
        }

        static void ThreadMessage(string data)
        {
            string message = string.Format("{0}\n  ThreadId is:{1}",
                   data,Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(message);
        }
    }

除此以外，也可以使用WailHandle完成同样的工作，WaitHandle里面包含有一个方法WaitOne（int timeout），它可以判断委托是否完成工作，在工作未完成前主线程可以继续其他工作。运行下面代码可得到与使用 IAsyncResult.IsCompleted 同样的结果，而且更简单方便

namespace Test
{
    class Program
    {
        delegate string MyDelegate(string name);

        static void Main(string[] args)
        {
            ThreadMessage("Main Thread");

            //建立委托
            MyDelegate myDelegate = new MyDelegate(Hello);

            //异步调用委托，获取计算结果
            IAsyncResult result=myDelegate.BeginInvoke("Leslie", null, null);

            while (!result.AsyncWaitHandle.WaitOne(200))
            {
                Console.WriteLine("Main thead do work!");
            }
            string data=myDelegate.EndInvoke(result);
            Console.WriteLine(data);

            Console.ReadKey();
        }

        static string Hello(string name)
        {
            ThreadMessage("Async Thread");
            Thread.Sleep(2000);
            return "Hello " + name;
        }

        static void ThreadMessage(string data)
        {
            string message = string.Format("{0}\n  ThreadId is:{1}",
                   data,Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(message);
        }
    }

当要监视多个运行对象的时候，使用IAsyncResult.WaitHandle.WaitOne可就派不上用场了

幸好.NET为WaitHandle准备了另外两个静态方法：

WaitAll（waitHandle[], int）

其中WaitAll在等待所有waitHandle完成后再返回一个bool值

WaitAny(waitHandle[] , int)

而WaitAny是等待其中一个waitHandle完成后就返回一个int，这个int是代表已完成waitHandle在waitHandle[]中的数组索引

下面就是使用WaitAll的例子，运行结果与使用 IAsyncResult.IsCompleted 相同

class Program
    {
        delegate string MyDelegate(string name);

        static void Main(string[] args)
        {
            ThreadMessage("Main Thread");

            //建立委托
            MyDelegate myDelegate = new MyDelegate(Hello);

            //异步调用委托，获取计算结果
            IAsyncResult result = myDelegate.BeginInvoke("Leslie", null, null);

            //此处可加入多个检测对象
            WaitHandle[] waitHandleList = new WaitHandle[] { result.AsyncWaitHandle};
            while (!WaitHandle.WaitAll(waitHandleList, 200))//第二个参数是时间，每隔多久轮询一次 
            {
                Console.WriteLine("Main thead do work!");
            }
            string data = myDelegate.EndInvoke(result);
            Console.WriteLine(data);

            Console.ReadKey();
        }

        static string Hello(string name)
        {
            ThreadMessage("Async Thread");
            Thread.Sleep(2000);
            return "Hello " + name;
        }

        static void ThreadMessage(string data)
        {
            string message = string.Format("{0}\n  ThreadId is:{1}",
                   data, Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(message);
        }
    }

8. 回调函数

使用轮询方式来检测异步方法的状态非常麻烦，而且效率不高，有见及此，.NET为 IAsyncResult BeginInvoke（AsyncCallback , object）准备了一个回调函数

使用 AsyncCallback 就可以绑定一个方法作为回调函数，回调函数必须是带参数 IAsyncResult 且无返回值的方法：

void

在BeginInvoke方法完成后，系统就会调用AsyncCallback所绑定的回调函数,最后回调函数中调用 XXX EndInvoke（IAsyncResult result) 就可以结束异步方法，它的返回值类型与委托的返回值一致

namespace MyAsyncCallback
{
    class Program
    {
        delegate string MyDelegate(string name);

        static void Main(string[] args)
        {
            ThreadMessage("Main Thread");

            //建立委托
            MyDelegate myDelegate = new MyDelegate(Hello);
            //异步调用委托，获取计算结果
            myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), null);
            //在启动异步线程后，主线程可以继续工作而不需要等待
            for (int n = 0; n < 6; n++)
                Console.WriteLine("  Main thread do work!");
            Console.WriteLine("");

            Console.ReadKey();
        }

        static string Hello(string name)
        {
            ThreadMessage("Async Thread");
            Thread.Sleep(2000);             //模拟异步操作
            return "\nHello " + name;
        }

        static void Completed(IAsyncResult result)
        {
            ThreadMessage("Async Completed");

            //获取委托对象，调用EndInvoke方法获取运行结果
            AsyncResult _result = (AsyncResult)result;
            MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
            string data = myDelegate.EndInvoke(_result);
            Console.WriteLine("-------------data = "+data);
        }

        static void ThreadMessage(string data)
        {
            string message = string.Format("{0}\n  ThreadId is:{1}",
                   data, Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(message);
        }
    }
}

可以看到，主线在调用BeginInvoke方法可以继续执行其他命令，而无需再等待了，这无疑比使用轮询方式判断异步方法是否完成更有优势

在异步方法执行完成后将会调用AsyncCallback所绑定的回调函数，注意一点，回调函数依然是在异步线程中执行，这样就不会影响主线程的运行，这也使用回调函数最值得青昧的地方

在回调函数中有一个既定的参数IAsyncResult，把IAsyncResult强制转换为AsyncResult后，就可以通过 AsyncResult.AsyncDelegate 获取原委托，再使用EndInvoke方法获取计算结果

运行结果如下：

public class Person
        {
            public string Name;
            public int Age;
        }

        delegate string MyDelegate(string name);

        static void Main(string[] args)
        {
            ThreadMessage("Main Thread");

            //建立委托
            MyDelegate myDelegate = new MyDelegate(Hello);

            //建立Person对象
            Person person = new Person();
            person.Name = "Elva";
            person.Age = 27;

            //异步调用委托，输入参数对象person, 获取计算结果
            myDelegate.BeginInvoke("Leslie", new AsyncCallback(Completed), person);

            //在启动异步线程后，主线程可以继续工作而不需要等待
            for (int n = 0; n < 6; n++)
                Console.WriteLine("  Main thread do work!");
            Console.WriteLine("");

            Console.ReadKey();
        }

        static string Hello(string name)
        {
            ThreadMessage("Async Thread");
            Thread.Sleep(2000);
            return "\nHello " + name;
        }

        static void Completed(IAsyncResult result)
        {
            ThreadMessage("Async Completed");

            //获取委托对象，调用EndInvoke方法获取运行结果
            AsyncResult _result = (AsyncResult)result;
            MyDelegate myDelegate = (MyDelegate)_result.AsyncDelegate;
            string data = myDelegate.EndInvoke(_result);
            //获取Person对象
            Person person = (Person)result.AsyncState;
            string message = person.Name + "'s age is " + person.Age.ToString();

            Console.WriteLine(data + "\n" + message);
        }

        static void ThreadMessage(string data)
        {
            string message = string.Format("{0}\n  ThreadId is:{1}",
                   data, Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine(message);
        }
    }

C多线程（三） -- CLR线程池的工作者线程

1. 关于CLR线程池

2. 工作者线程与I/O线程

3. API

4. 使用 CLR 工作者线程

5. 通过QueueUserWorkItem启动工作者线程

5. 委托类

6. 利用BeginInvoke与EndInvoke完成异步委托方法

7. 善用IAsyncResult

8. 回调函数

继续阅读

线程池创建多少线程比较合理？线程池创建多少线程比较合理？

ExecutorService基本知识点学习，不同的线程池使用场景区分

Java并发编程之线程池的关闭

Java.util.concurrent之 Executor框架与线程池

线程池常用的阻塞队列有哪些？线程池常用的阻塞队列有哪些？

Springboot中异步操作的最佳实现方式

python爬取使用线程池出现报错：exception calling callback for <；Future at 0x1e8e963ef70 state=finished raised

游戏服务器架构基本模块及其作用

CLR线程池的工作者线程

基于事件的异步调用模式

Java并发编程一四种常用线程池简述

Java并发编程一线程池简介

Java网络编程-Socket编程初涉五（AIO模型的简易客户端-服务器）

Java并发编程一如何关闭线程池

python3源码剖析之concurrent.futures.ThreadPoolExecutor

Java并发编程一线程池的五种状态