C多线程(三) -- CLR线程池的工作者线程
2017-03-16 10:31
218 查看
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
默认最小线程数 = 处理器数
代码验证给你看看:
int i = 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 WaitCallback(AsyncCallback)); Console.ReadKey(); } }
使用 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.委托(需要异步调用的方法) --> MyDelegate myDelegate = new MyDelegate(Hello); /// 2.异步调用 IAsyncResult result = myDelegate.BeginInvoke(); /// 3.异步方法完成后,接受结果 --> string data = myDelegate.EndInvoke(result); /// </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 AsycnCallbackMethod(IAsyncResult result)
在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方法获取计算结果
运行结果如下:
如果想为回调函数传送一些外部信息,就可以利用BeginInvoke(AsyncCallback,object)的最后一个参数object,它允许外部向回调函数输入任何类型的参数。只需要在回调函数中利用 AsyncResult.AsyncState 就可以获取object对象
class Program { 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); } }
相关文章推荐
- CLR线程池的工作者线程
- 细说多线程(四)—— CLR线程池的工作者线程
- [.Net线程处理系列]专题二:线程池中的工作者线程
- 《CLR via C#》之线程处理——线程池与任务
- [.Net线程处理系列]专题二:线程池中的工作者线程
- [.Net线程处理系列]专题二:线程池中的工作者线程
- [C# 线程处理系列]专题二:线程池中的工作者线程
- 细说多线程(五) —— CLR线程池的I/O线程
- CLR线程池的I/O线程
- [C# 线程处理系列]专题三:线程池中的工作者线程
- 线程机制、CLR线程池以及应用程序域
- 转:专题二线程池中的工作者线程
- 线程池中的工作者线程
- [.Net 多线程处理系列]专题二:线程池中的工作者线程
- [.Net线程处理系列]专题二:线程池中的工作者线程
- CLR via C# 读书笔记 1-1 何时使用线程或者线程池
- [C# 线程处理系列]专题三:线程池中的工作者线程
- 线程池中的工作者线程
- 线程系列06,通过CLR代码查看线程池及其线程
- 用 MFC 类库编程实现工作者线程