[.Net线程处理系列]专题二：线程池中的工作者线程

2025-01-22 技术教程

一、上节补充

二、CLR线程池基础

三、通过线程池的工作者线程实现异步

四、使用委托实现异步

五、任务

六、小结

一、上节补充

对于Thread类还有几个常用方法需要说明的。

1.1 Suspend和Resume方法

这两个方法在.net Framework 1.0 的时候就支持的方法，他们分别可以挂起线程和恢复挂起的线程。但在.net Framework 2.0以后的版本中这两个方法都过时了，MSDN的解释是这样：

警告：

不要使用 Suspend 和 Resume 方法来同步线程的活动。您无法知道挂起线程时它正在执行什么代码。如果您在安全权限评估期间挂起持有锁的线程，则 AppDomain中的其他线程可能被阻止。如果您在线程正在执行类构造函数时挂起它，则 AppDomain中尝试使用该类的其他线程将被阻止。这样很容易发生死锁。

对于这个解释可能有点抽象吧，让我们来看看一段代码可能会清晰点：

classProgram { staticvoidMain(string[]args) { //创建一个线程来测试 Threadthread1=newThread(TestMethod); thread1.Name="Thread1"; thread1.Start(); Thread.Sleep(2000); Console.WriteLine("MainThreadisrunning"); ////intb=0; ////inta=3/b; ////Console.WriteLine(a); thread1.Resume(); Console.Read(); } privatestaticvoidTestMethod() { Console.WriteLine("Thread:{0}hasbeensuspended!",Thread.CurrentThread.Name); //将当前线程挂起 Thread.CurrentThread.Suspend(); Console.WriteLine("Thread:{0}hasbeenresumed!",Thread.CurrentThread.Name); } } 在上面这段代码中thread1线程是在主线程中恢复的，但当主线程发生异常时，这时候就thread1一直处于挂起状态，此时thread1所使用的资源就不能释放（除非强制终止进程），当另外线程需要使用这快资源的时候，这时候就很可能发生死锁现象。

上面一段代码还存在一个隐患，请看下面一小段代码：

classProgram { staticvoidMain(string[]args) { //创建一个线程来测试 Threadthread1=newThread(TestMethod); thread1.Name="Thread1"; thread1.Start(); Console.WriteLine("MainThreadisrunning"); thread1.Resume(); Console.Read(); } privatestaticvoidTestMethod() { Console.WriteLine("Thread:{0}hasbeensuspended!",Thread.CurrentThread.Name); Thread.Sleep(1000); //将当前线程挂起 Thread.CurrentThread.Suspend(); Console.WriteLine("Thread:{0}hasbeenresumed!",Thread.CurrentThread.Name); } }

当主线程跑（运行）的太快,做完自己的事情去唤醒thread1时，此时thread1还没有挂起而起唤醒thread1,此时就会出现异常了。并且上面使用的Suspend和Resume方法，编译器已经出现警告了，提示这两个方法已经过时，所以在我们平时使用中应该尽量避免。

1.2 Abort和 Interrupt方法

Abort方法和Interrupt都是用来终止线程的，但是两者还是有区别的。

1、他们抛出的异常不一样，Abort 方法抛出的异常是ThreadAbortException， Interrupt抛出的异常为ThreadInterruptedException

2、调用interrupt方法的线程之后可以被唤醒，然而调用Abort方法的线程就直接被终止不能被唤醒的。

下面一段代码是演示Abort方法的使用

usingSystem; usingSystem.Threading; namespaceConsoleApplication1 { classProgram { staticvoidMain(string[]args) { ThreadabortThread=newThread(AbortMethod); abortThread.Name="AbortThread"; abortThread.Start(); Thread.Sleep(1000); try{ abortThread.Abort(); } catch { Console.WriteLine("{0}ExceptionhappeninMainThread",Thread.CurrentThread.Name); Console.WriteLine("{0}Statusis:{1}InMainThread",Thread.CurrentThread.Name,Thread.CurrentThread.ThreadState); } finally{ Console.WriteLine("{0}Statusis:{1}InMainThread",abortThread.Name,abortThread.ThreadState); } abortThread.Join(); Console.WriteLine("{0}Statusis:{1}",abortThread.Name,abortThread.ThreadState); Console.Read(); } privatestaticvoidAbortMethod() { try{ Thread.Sleep(5000); } catch(Exceptione) { Console.WriteLine(e.GetType().Name); Console.WriteLine("{0}ExceptionhappenInAbortThread",Thread.CurrentThread.Name); Console.WriteLine("{0}Statusis:{1}InAbortThread",Thread.CurrentThread.Name,Thread.CurrentThread.ThreadState); } finally{ Console.WriteLine("{0}Statusis:{1}InAbortThread",Thread.CurrentThread.Name,Thread.CurrentThread.ThreadState); } } }运行结果：

从运行结果可以看出，调用Abort方法的线程引发的异常类型为ThreadAbortException, 以及异常只会在调用Abort方法的线程中发生，而不会在主线程中抛出，并且调用Abort方法后线程的状态不是立即改变为Aborted状态，而是从AbortRequested->Aborted。

Interrupt方法：

usingSystem; usingSystem.Threading; namespaceConsoleApplication1 { classProgram { staticvoidMain(string[]args) {ThreadinterruptThread=newThread(AbortMethod); interruptThread.Name="InterruptThread"; interruptThread.Start(); interruptThread.Interrupt(); interruptThread.Join(); Console.WriteLine("{0}Statusis:{1}",interruptThread.Name,interruptThread.ThreadState); Console.Read(); } privatestaticvoidAbortMethod() { try{ Thread.Sleep(5000); } catch(Exceptione) { Console.WriteLine(e.GetType().Name); Console.WriteLine("{0}ExceptionhappenInInterruptThread",Thread.CurrentThread.Name); Console.WriteLine("{0}Statusis:{1}InInterruptThread",Thread.CurrentThread.Name,Thread.CurrentThread.ThreadState); } finally{ Console.WriteLine("{0}Statusis:{1}InInterruptThread",Thread.CurrentThread.Name,Thread.CurrentThread.ThreadState); } } } }运行结果：

从结果中可以得到，调用Interrupt方法抛出的异常为：ThreadInterruptException, 以及当调用Interrupt方法后线程的状态应该是中断的，但是从运行结果看此时的线程因为了Join,Sleep方法而唤醒了线程，为了进一步解释调用Interrupt方法的线程可以被唤醒，我们可以在线程执行的方法中运用循环，如果线程可以唤醒，则输出结果中就一定会有循环的部分，然而调用Abort方法线程就直接终止，就不会有循环的部分，下面代码相信大家看后肯定会更加理解两个方法的区别的：

usingSystem; usingSystem.Threading; namespaceConsoleApplication2 { classProgram { staticvoidMain(string[]args) { Threadthread1=newThread(TestMethod); thread1.Start(); Thread.Sleep(100); thread1.Interrupt(); Thread.Sleep(3000); Console.WriteLine("afterfinnallyblock,theThread1statusis:{0}",thread1.ThreadState); Console.Read(); } privatestaticvoidTestMethod() { for(inti=0;i<4;i++) { try{ Thread.Sleep(2000); Console.WriteLine("ThreadisRunning"); } catch(Exceptione) { if(e!=null) { Console.WriteLine("Exception{0}throw",e.GetType().Name); } } finally{ Console.WriteLine("CurrentThreadstatusis:{0}",Thread.CurrentThread.ThreadState); } } } } }运行结果为：

如果把上面的 thread1.Interrupt();改为 thread1.Abort(); 运行结果为：

二、线程池基础

首先，创建和销毁线程是一个要耗费大量时间的过程，另外，太多的线程也会浪费内存资源，所以通过Thread类来创建过多的线程反而有损于性能，为了改善这样的问题，.net中就引入了线程池。

线程池形象的表示就是存放应用程序中使用的线程的一个集合（就是放线程的地方，这样线程都放在一个地方就好管理了）。CLR初始化时，线程池中是没有线程的，在内部，线程池维护了一个操作请求队列，当应用程序想执行一个异步操作时，就调用一个方法，就将一个任务放到线程池的队列中，线程池中代码从队列中提取任务，将这个任务委派给一个线程池线程去执行，当线程池线程完成任务时，线程不会被销毁，而是返回到线程池中，等待响应另一个请求。由于线程不被销毁，这样就可以避免因为创建线程所产生的性能损失。

注意：通过线程池创建的线程默认为后台线程，优先级默认为Normal.

三、通过线程池的工作者线程实现异步

3.1 创建工作者线程的方法

public static bool QueueUserWorkItem (WaitCallback callBack);

public static bool QueueUserWorkItem(WaitCallback callback, Object state);

这两个方法向线程池的队列添加一个工作项（work item）以及一个可选的状态数据。然后，这两个方法就会立即返回。

工作项其实就是由callback参数标识的一个方法，该方法将由线程池线程执行。同时写的回调方法必须匹配System.Threading.WaitCallback委托类型，定义为：

public delegate void WaitCallback(Object state);

下面演示如何通过线程池线程来实现异步调用：

usingSystem; usingSystem.Threading; namespaceThreadPoolUse { classProgram { staticvoidMain(string[]args) { //设置线程池中处于活动的线程的最大数目 //设置线程池中工作者线程数量为1000，I/O线程数量为1000 ThreadPool.SetMaxThreads(1000,1000); Console.WriteLine("MainThread:queueanasynchronousmethod"); PrintMessage("MainThreadStart"); //把工作项添加到队列中，此时线程池会用工作者线程去执行回调方法 ThreadPool.QueueUserWorkItem(asyncMethod); Console.Read(); } //方法必须匹配WaitCallback委托 privatestaticvoidasyncMethod(objectstate) { Thread.Sleep(1000); PrintMessage("AsynchoronousMethod"); Console.WriteLine("Asynchoronousthreadhasworked"); } //打印线程池信息 privatestaticvoidPrintMessage(Stringdata) { intworkthreadnumber; intiothreadnumber; //获得线程池中可用的线程，把获得的可用工作者线程数量赋给workthreadnumber变量 //获得的可用I/O线程数量给iothreadnumber变量 ThreadPool.GetAvailableThreads(outworkthreadnumber,outiothreadnumber); Console.WriteLine("{0}\nCurrentThreadIdis{1}\nCurrentThreadisbackground:{2}\nWorkerThreadNumberis:{3}\nIOThreadNumbersis:{4}\n", data, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsBackground.ToString(), workthreadnumber.ToString(), iothreadnumber.ToString()); } } }运行结果：

从结果中可以看出，线程池中的可用的工作者线程少了一个，用去执行回调方法了。

ThreadPool.QueueUserWorkItem(WaitCallback callback,Object state) 方法可以把object对象作为参数传送到回调函数中,使用和ThreadPool.QueueUserWorkItem(WaitCallback callback)的使用和类似，这里就不列出了。

3.2 协作式取消

.net Framework提供了取消操作的模式，这个模式是协作式的。为了取消一个操作，首先必须创建一个System.Threading.CancellationTokenSource对象。

下面代码演示了协作式取消的使用，主要实现当用户在控制台敲下回车键后就停止数数方法。

usingSystem; usingSystem.Collections.Generic; usingSystem.Linq; usingSystem.Text; usingSystem.Threading; namespaceConsoleApplication3 { classProgram { staticvoidMain(string[]args) { ThreadPool.SetMaxThreads(1000,1000); Console.WriteLine("Mainthreadrun"); PrintMessage("Start"); Run(); Console.ReadKey(); } privatestaticvoidRun() { CancellationTokenSourcects=newCancellationTokenSource(); //这里用Lambda表达式的方式和使用委托的效果一样的，只是用了Lambda后可以少定义一个方法。 //这在这里就是让大家明白怎么lambda表达式如何由委托转变的 ////ThreadPool.QueueUserWorkItem(o=>Count(cts.Token,1000)); ThreadPool.QueueUserWorkItem(callback,cts.Token); Console.WriteLine("PressEnterkeytocanceltheoperation\n"); Console.ReadLine(); //传达取消请求 cts.Cancel(); } privatestaticvoidcallback(objectstate) { Thread.Sleep(1000); PrintMessage("AsynchoronousMethodStart"); CancellationTokentoken=(CancellationToken)state; Count(token,1000); } //执行的操作，当受到取消请求时停止数数 privatestaticvoidCount(CancellationTokentoken,intcountto) { for(inti=0;i<countto;i++) { if(token.IsCancellationRequested) { Console.WriteLine("Countiscanceled"); break; } Console.WriteLine(i); Thread.Sleep(300); } Console.WriteLine("Couthasdone"); } //打印线程池信息 privatestaticvoidPrintMessage(Stringdata) { intworkthreadnumber; intiothreadnumber; //获得线程池中可用的线程，把获得的可用工作者线程数量赋给workthreadnumber变量 //获得的可用I/O线程数量给iothreadnumber变量 ThreadPool.GetAvailableThreads(outworkthreadnumber,outiothreadnumber); Console.WriteLine("{0}\nCurrentThreadIdis{1}\nCurrentThreadisbackground:{2}\nWorkerThreadNumberis:{3}\nIOThreadNumbersis:{4}\n", data, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsBackground.ToString(), workthreadnumber.ToString(), iothreadnumber.ToString()); } } }运行结果：

四、使用委托实现异步

通过调用ThreadPool的QueueUserWorkItem方法来来启动工作者线程非常方便，但委托WaitCallback指向的是带有一个参数的无返回值的方法，如果我们实际操作中需要有返回值，或者需要带有多个参数，这时通过这样的方式就难以实现，为了解决这样的问题，我们可以通过委托来建立工作这线程，

下面代码演示了使用委托如何实现异步：

usingSystem; usingSystem.Threading; namespaceDelegate { classProgram { //使用委托的实现的方式是使用了异步变成模型APM（AsynchronousProgrammingModel） //自定义委托 privatedelegatestringMyTestdelegate(); staticvoidMain(string[]args) { ThreadPool.SetMaxThreads(1000,1000); PrintMessage("MainThreadStart"); //实例化委托 MyTestdelegatetestdelegate=newMyTestdelegate(asyncMethod); //异步调用委托 IAsyncResultresult=testdelegate.BeginInvoke(null,null); //获取结果并打印出来 stringreturndata=testdelegate.EndInvoke(result); Console.WriteLine(returndata); Console.ReadLine(); } privatestaticstringasyncMethod() { Thread.Sleep(1000); PrintMessage("AsynchoronousMethod"); return"Methodhascompleted"; } //打印线程池信息 privatestaticvoidPrintMessage(Stringdata) { intworkthreadnumber; intiothreadnumber; //获得线程池中可用的线程，把获得的可用工作者线程数量赋给workthreadnumber变量 //获得的可用I/O线程数量给iothreadnumber变量 ThreadPool.GetAvailableThreads(outworkthreadnumber,outiothreadnumber); Console.WriteLine("{0}\nCurrentThreadIdis{1}\nCurrentThreadisbackground:{2}\nWorkerThreadNumberis:{3}\nIOThreadNumbersis:{4}\n", data, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsBackground.ToString(), workthreadnumber.ToString(), iothreadnumber.ToString()); } } }运行结果：

五、任务

同样任务的引入也是为了解决通过ThreadPool.QueueUserWorkItem中限制的问题，

下面代码演示通过任务来实现异步：

5.1 使用任务来实现异步

usingSystem; usingSystem.Threading; usingSystem.Threading.Tasks; namespaceTaskUse { classProgram { staticvoidMain(string[]args) { ThreadPool.SetMaxThreads(1000,1000); PrintMessage("MainThreadStart"); //调用构造函数创建Task对象, Task<int>task=newTask<int>(n=>asyncMethod((int)n),10); //启动任务 task.Start(); //等待任务完成 task.Wait(); Console.WriteLine("TheMethodresultis:"+task.Result); Console.ReadLine(); } privatestaticintasyncMethod(intn) { Thread.Sleep(1000); PrintMessage("AsynchoronousMethod"); intsum=0; for(inti=1;i<n;i++) { //如果n太大，使用checked使下面代码抛出异常 checked{ sum+=i; } } returnsum; } //打印线程池信息 privatestaticvoidPrintMessage(Stringdata) { intworkthreadnumber; intiothreadnumber; //获得线程池中可用的线程，把获得的可用工作者线程数量赋给workthreadnumber变量 //获得的可用I/O线程数量给iothreadnumber变量 ThreadPool.GetAvailableThreads(outworkthreadnumber,outiothreadnumber); Console.WriteLine("{0}\nCurrentThreadIdis{1}\nCurrentThreadisbackground:{2}\nWorkerThreadNumberis:{3}\nIOThreadNumbersis:{4}\n", data, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsBackground.ToString(), workthreadnumber.ToString(), iothreadnumber.ToString()); } } }运行结果：

5.2 取消任务

如果要取消任务，同样可以使用一个CancellationTokenSource对象来取消一个Task.

下面代码演示了如何来取消一个任务：

usingSystem; usingSystem.Threading; usingSystem.Threading.Tasks; namespaceTaskUse { classProgram { staticvoidMain(string[]args) { ThreadPool.SetMaxThreads(1000,1000); PrintMessage("MainThreadStart"); CancellationTokenSourcects=newCancellationTokenSource(); //调用构造函数创建Task对象,将一个CancellationToken传给Task构造器从而使Task和CancellationToken关联起来 Task<int>task=newTask<int>(n=>asyncMethod(cts.Token,(int)n),10); //启动任务 task.Start(); //延迟取消任务 Thread.Sleep(3000); //取消任务 cts.Cancel(); Console.WriteLine("TheMethodresultis:"+task.Result); Console.ReadLine(); } privatestaticintasyncMethod(CancellationTokenct,intn) { Thread.Sleep(1000); PrintMessage("AsynchoronousMethod"); intsum=0; try{ for(inti=1;i<n;i++) { //当CancellationTokenSource对象调用Cancel方法时， //就会引起OperationCanceledException异常 //通过调用CancellationToken的ThrowIfCancellationRequested方法来定时检查操作是否已经取消， //这个方法和CancellationToken的IsCancellationRequested属性类似 ct.ThrowIfCancellationRequested(); Thread.Sleep(500); //如果n太大，使用checked使下面代码抛出异常 checked{ sum+=i; } } } catch(Exceptione) { Console.WriteLine("Exceptionis:"+e.GetType().Name); Console.WriteLine("OperationisCanceled"); } returnsum; } //打印线程池信息 privatestaticvoidPrintMessage(Stringdata) { intworkthreadnumber; intiothreadnumber; //获得线程池中可用的线程，把获得的可用工作者线程数量赋给workthreadnumber变量 //获得的可用I/O线程数量给iothreadnumber变量 ThreadPool.GetAvailableThreads(outworkthreadnumber,outiothreadnumber); Console.WriteLine("{0}\nCurrentThreadIdis{1}\nCurrentThreadisbackground:{2}\nWorkerThreadNumberis:{3}\nIOThreadNumbersis:{4}\n", data, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsBackground.ToString(), workthreadnumber.ToString(), iothreadnumber.ToString()); } } }运行结果：

5.3 任务工厂

同样可以通过任务工厂TaskFactory类型来实现异步操作。

usingSystem; usingSystem.Threading; usingSystem.Threading.Tasks; namespaceTaskFactory { classProgram { staticvoidMain(string[]args) { ThreadPool.SetMaxThreads(1000,1000); Task.Factory.StartNew(()=>PrintMessage("MainThread")); Console.Read(); } //打印线程池信息 privatestaticvoidPrintMessage(Stringdata) { intworkthreadnumber; intiothreadnumber; //获得线程池中可用的线程，把获得的可用工作者线程数量赋给workthreadnumber变量 //获得的可用I/O线程数量给iothreadnumber变量 ThreadPool.GetAvailableThreads(outworkthreadnumber,outiothreadnumber); Console.WriteLine("{0}\nCurrentThreadIdis{1}\nCurrentThreadisbackground:{2}\nWorkerThreadNumberis:{3}\nIOThreadNumbersis:{4}\n", data, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsBackground.ToString(), workthreadnumber.ToString(), iothreadnumber.ToString()); } } }运行结果：

六、小结

讲到这里CLR的工作者线程大致讲完了，希望也篇文章可以让大家对线程又有进一步的理解。在后面的一篇线程系列将谈谈CLR线程池的I/O线程。