多线程学习系列：（六）线程池基础下

这节我们按照线程池的核心思想来自定义一个简单的线程池：

　　1） 池中使用的线程不少于一定数量，不多于一定数量

　　2） 池中线程不够的时候创建，富裕的时候收回

　　3） 任务排队，没有可用线程时，任务等待

　　我们的目的只是实现这些“需求”，不去考虑性能（比如等待一段时间再去创建新的线程等策略）以及特殊的处理（异常），在实现这个需求的过程中我们也回顾了线程以及线程同步的基本概念。

　　首先，把任务委托和任务需要的状态数据封装一个对象：

public　class　WorkItem　
{　
　　public　WaitCallback　Action　{　get;　set;　}　
　　public　object　State　{　get;　set;　}　
　
　　public　WorkItem(WaitCallback　action,　object　state)　
　　{　
　　　　this.Action　=　action;　
　　　　this.State　=　state;　
　　}　
}

　　然后来创建一个对象作为线程池中的一个线程：

public　class　SimpleThreadPoolThread　
{　
　　private　object　locker　=　new　object();　
　　private　AutoResetEvent　are　=　new　AutoResetEvent(false);　
　　private　WorkItem　wi;　
　　private　Thread　t;　
　　private　bool　b　=　true;　
　　private　bool　isWorking;　
　
　　public　bool　IsWorking　
　　{　
　　　　get　
　　　　{　
　　　　　　lock　(locker)　
　　　　　　{　
　　　　　　　　return　isWorking;　
　　　　　　}　
　　　　}　
　　}　
　　public　event　Action<SimpleThreadPoolThread>　WorkComplete;　
　
　　public　SimpleThreadPoolThread()　
　　{　
　　　　lock　(locker)　
　　　　{　
　　　　　　//　当前没有实际任务　
　　　　　　isWorking　=　false;　
　　　　}　
　　　　t　=　new　Thread(Work)　{　IsBackground　=　true　};　
　　　　t.Start();　
　　}　
　
　　public　void　SetWork(WorkItem　wi)　
　　{　
　　　　this.wi　=　wi;　
　　}　
　
　　public　void　StartWork()　
　　{　
　　　　//　发出信号　
　　　　are.Set();　
　　}　
　
　　public　void　StopWork()　
　　{　
　　　　//　空任务　
　　　　wi　=　null;　
　　　　//　停止线程循环　
　　　　b　=　false;　
　　　　//　发出信号结束线程　
　　　　are.Set();　
　　}　
　
　　private　void　Work()　
　　{　
　　　　while　(b)　
　　　　{　
　　　　　　//　没任务，等待信号　
　　　　　　are.WaitOne();　
　　　　　　if　(wi　!=　null)　
　　　　　　{　
　　　　　　　　lock　(locker)　
　　　　　　　　{　
　　　　　　　　　　//　开始　
　　　　　　　　　　isWorking　=　true;　
　　　　　　　　}　
　　　　　　　　//　执行任务　
　　　　　　　　wi.Action(wi.State);　
　　　　　　　　lock　(locker)　
　　　　　　　　{　
　　　　　　　　　　//　结束　
　　　　　　　　　　isWorking　=　false;　
　　　　　　　　}　
　　　　　　　　//　结束事件　
　　　　　　　　WorkComplete(this);　
　　　　　　}　
　　　　}　
　　}