分享一个自制的 .net线程池
扯淡
因为项目需求，须要开发一些程序去爬取一些网站的信息，算是小爬虫程序吧。爬网页这东西是要通过网络传输，若是程序运行起来串行执行请求爬取，会很慢，我想没人会这样作。为了提升爬取效率，必须使用多线程并行爬取。这时候就须要线程池了。池的概念，我想作开发的都应该知道，目的就是对资源的合理运用。刚开始的时候，我首先想到的就是 .net 框架下的线程池 ThreadPool，毕竟是自带的，在性能、稳定性方面确定没问题。但在琢磨了几天后，.net 框架下自带的这个 ThreadPool 让我很不放心。1.ThreadPool 是一个静态类！！也就是说，当程序运行起来之后，这个池是整个应用程序域共享的，.net 框架很大，程序运行了之后，除了我们本身往这个共享池里塞任务，谁知道有没有其余的类、代码、任务也会往里塞 workItem 呢？也就是说，假如我设置这个共享池大小为 10，但实际为咱们工做的线程会不到 10 个，这就会致使程序运行时达不到咱们预期的效果。2.目前咱们的爬虫程序设计是像一个服务同样挂着，只要程序启动了之后就会一直运行着，除非手动中止。所以，在没有爬取任务的时候，须要减小甚至清空池内的全部线程，以避免池内线程一直挂着占用系统资源。因为 .net 自带的这个线程池是共享的，我还真不敢随意调整它的大小，对于我这种控制欲极强的程序员来讲，这是万万接受不了的。虽然.net 自带的 ThreadPool 用法简单，功能强大，并且它还能够智能的调节池内线程池数量，但我仍是决定抛弃它，由于，我须要一个可控的线程池！因而开始到网上处处查找有没有其它现成的线程池。百度、谷歌了很久，发如今.net界比较成熟的就 SmartThreadPool，对 SmartThreadPool 简单了解之后，仍是以为它不是我想要的，因而决定，自造一个。因而，借助强大的网络，又开始网上处处搜索有关线程池如何实现以及相关注意事项之类的信息，也拜读过一些网上开源的项目，如 .net 的 SmartThreadPool、java 里的 ThreadPoolExecutor 等，虽然没接触过 java，但 java 和 C# 犹如亲兄弟，大同小异，让我这 .net coder 读起来不是很费劲。基于前人的实现思路，再融入本身的思想，脑中本身的池也慢慢浮现…java
线程池：IThreadPool
根据需求，首先定义基本接口程序员
public interface IThreadPool : IDisposable { /// <summary> /// 线程池大小 /// </summary> int Threads { get; set; } /// <summary> /// 一个以毫秒为单位的值，表示从最后一个活动的线程执行完任务后开始计时，在指定的时间内线程池都没有接收到任何任务，则释放掉池内的全部线程。若设置值小于 0，则不会释放池内线程。如未指定，默认为 -1。 /// </summary> double KeepAliveTime { get; set; } /// <summary> /// 获取当前线程池内的空闲线程数量 /// </summary> /// <returns></returns> int GetAvailableThreads(); /// <summary> /// 获取当前线程池内工做项总数 /// </summary> /// <returns></returns> int GetWorkCount(); /// <summary> /// 向线程池中添加工做项 /// </summary> /// <param name="callback"></param> /// <param name="state"></param> /// <returns></returns> bool QueueWorkItem(WaitCallback callback, object state); }
能够看到，我定义的线程池接口成员就几个(命名都是来自 .net 自带 ThreadPool，哈哈)，它们的用途上面代码也都带有注释。接下来，咱们看下核心实现。首先，介绍类 WorkerThread：服务器
internal class WorkerThread : IDisposable { Thread _thread; AutoResetEvent _waitEvent; Action _action; bool _disposed = false; public WorkerThread() { this._waitEvent = new AutoResetEvent(false); this._thread = new Thread(this.Run); this._thread.IsBackground = true; this._thread.Start(); } //是否正在执行工做 public bool IsWorking { get; private set; } public event Action<WorkerThread> Complete; public int ThreadId { get { return this._thread.ManagedThreadId; } } public ThreadState ThreadState { get { return this._thread.ThreadState; } } public void SetWork(Action act) { this.CheckDisposed(); if (this.IsWorking) throw new Exception("正在执行工做项"); this._action = act; } public void Activate() { this.CheckDisposed(); if (this.IsWorking) throw new Exception("正在执行工做项"); if (this._action == null) throw new Exception("未设置任何工做项"); this._waitEvent.Set(); } void Run() { while (!this._disposed) { this._waitEvent.WaitOne(); if (this._disposed) break; try { this.IsWorking = true; this._action(); } catch (ThreadAbortException) { if (!this._disposed) Thread.ResetAbort(); } catch (Exception) { } finally { this.IsWorking = false; this._action = null; var completeEvent = this.Complete; if (completeEvent != null) { try { completeEvent(this); } catch { } } } } } void CheckDisposed() { if (this._disposed) throw new ObjectDisposedException(this.GetType().Name); } public void Dispose() { if (this._disposed) return; try { this._disposed = true; //注意：只有调用 Dispose() 的不是当前对象维护的线程才调用 Abort if (Thread.CurrentThread.ManagedThreadId != this._thread.ManagedThreadId) { this._thread.Abort(); } } finally { this._waitEvent.Dispose(); } } }
这个类主要是对线程的封装，我称之为 WorkerThread。它主要负责接收线程池分配的一个任务，而后执行，线程池内维护的就是这么一个类对象。介绍下它的几个核心成员：网络
- _action：一个 Action 类型的字段。也就是一个委托，也就是 WorkerThread 要执行的任务，经过 SetWork(Action act) 方法设置值
- _thread：一个 Thread 对象。也就是真正执行任务的线程
- _waitEvent：一个 AutoResetEvent 对象。线程池的做用就是池内维护必定数量可重复利用的线程，线程执行每一个任务之后，并非直接“天然”结束，而是继续执行下一个任务，当没有可执行的任务的时候就会驻留在线程池内等待有可执行的任务。因此，如何让一个线程处于等待状态，而不是直接“天然”结束呢？我是经过这个 AutoResetEvent 对象去控制的。这个对象主要有 WaitOne() 和 Set() 两个方法，WaitOne() 用于“卡”住线程，让线程处于停滞状态，Set() 就是用于通知线程继续执行（关于这两个方法的使用以及介绍我就通俗的说明下，若是不熟悉这个类的同窗能够自行查 msdn）。这两个方法，在配合一个 while 循环，基本就实现了线程的复用，具体看 Run() 方法。
- Complete：一个 Action<WorkerThread> 类型的事件。每次执行完任务都会调用该事件，做用就是通知其所在线程池，说明”我“已经执行完”你“分配的任务了。
- SetWork(Action act)：设置线程要执行的任务，其实就是设置字段 _action 的值。这个方法是提供给线程池用的，每次给 WorkerThread 分配任务都是经过调用这个方法。
- Activate()：激活 WorkerThread 执行任务。调用了 SetWork(Action act) 分配任务了之后，就会调用该方法执行任务。这方法里主要就是调用 _waitEvent.Set() 方法触发 _thread 线程继续执行。
- Run()：这是 WorkerThread 对象的核心。建立 _thread 时，给 _thread 设置执行的就是这个 Run() 方法。这个方法内实现就是一个 while 循环，每循环一次就会调用 _waitEvent.WaitOne() “卡“住线程，直到被调用 Activate() 才会执行后续代码，后续代码也就是执行真正的任务 _action。执行完任务了之后进入到下一个循环等待，直到接收下一个任务和被再次调用 Activate()…如此循环…. 从而达到了咱们循环利用线程的目的
WorkerThread 这个类代码也不是不少，百来行而已。总结来讲它做用就是 SetWork(Action act) –> Activate() –> _action() –> WaitOne() –> SetWork(Action act) –> Activate()…无限循环…但愿你们看得明白。多线程
了解 WorkerThread 了之后，再来看下真正实现 IThreadPool 接口的类 WorkerThreadPool。前面提到，线程池的做用就是池内维护必定数量可重复利用的线程，WorkerThreadPool 负责 WorkerThread 的建立、接收用户任务并将任务分配给池内空闲的线程去执行用户任务，功能其实就这么简单。废话很少说，直接上代码：框架
public class WorkerThreadPool : IThreadPool, IDisposable { readonly object _lockObject = new object(); bool _disposed = false; bool _spin = false; //spin 每调用一次 QueueWorkItem 方法都会将 spin 设为 false，以通知计时线程中止循环了 double _keepAliveTime = -1;//等待时间，表示从最后一个活动的线程执行完任务后开始计时到必定的时间内都没有接受到任何任务，则释放掉池内的全部线程 DateTime _releaseTime = DateTime.Now;//释放线程的时间点 int _threads; List<WorkerThread> _allThreads; List<WorkerThread> _workingTreads; Queue<WorkerThread> _freeTreads; Queue<WorkItem> _workQueue; List<ReleaseThreadsRecord> _releaseThreadsRecords = new List<ReleaseThreadsRecord>(); /// <summary> /// 建立一个线程池，默认 Threads 为 25 /// </summary> public WorkerThreadPool() : this(25) { } /// <summary> /// 建立一个大小为 threads 的线程池 /// </summary> /// <param name="threads"></param> public WorkerThreadPool(int threads) { if (threads < 1) throw new ArgumentException("threads 小于 1"); this._threads = threads; this._allThreads = new List<WorkerThread>(threads); this._workingTreads = new List<WorkerThread>(threads); this._freeTreads = new Queue<WorkerThread>(threads); this._workQueue = new Queue<WorkItem>(); } /// <summary> /// /// </summary> ~WorkerThreadPool() { this.Dispose(); } /// <summary> /// 线程池大小 /// </summary> public int Threads { get { return this.GetPoolSize(); } set { this.SetPoolSize(value); } } /// <summary> /// 一个以毫秒为单位的值，表示从最后一个活动的线程执行完任务后开始计时，在指定的时间内线程池都没有接受到任何任务，则释放掉池内的全部线程。若设置值小于 0，则不会释放池内线程。如未指定，默认为 -1。 /// </summary> public double KeepAliveTime { get { return this._keepAliveTime; } set { this._keepAliveTime = value; } } int GetPoolSize() { return this._threads; } void SetPoolSize(int threads) { if (threads < 1) throw new ArgumentException("threads 小于 1"); lock (this._lockObject) { this._threads = threads; this.AdjustPool(); WorkerThread workerThread = null; WorkItem workItem = null; while (this.TryGetWorkerThreadAndWorkItem(out workerThread, out workItem, false)) { this.ActivateWorkerThread(workerThread, workItem); workerThread = null; workItem = null; } } } /// <summary> /// 获取当前线程池内的空闲线程数量 /// </summary> /// <returns></returns> public int GetAvailableThreads() { lock (this._lockObject) { if (this._threads <= this._workingTreads.Count) return 0; int r = this._threads - this._workingTreads.Count; return r; } } /// <summary> /// 获取当前线程池内工做项总数 /// </summary> /// <returns></returns> public int GetWorkCount() { lock (this._lockObject) { return this._workQueue.Count + this._workingTreads.Count; } } /// <summary> /// 向线程池中添加工做项 /// </summary> /// <param name="callback"></param> /// <param name="state"></param> /// <returns></returns> public bool QueueWorkItem(WaitCallback callback, object state) { if (callback == null) return false; WorkerThread workerThread = null; WorkItem workItem = null; lock (this._lockObject) { CheckDisposed(); if (this._workQueue.Count == int.MaxValue) return false; this._workQueue.Enqueue(new WorkItem(callback, state)); this._spin = false; if (!this.TryGetWorkerThreadAndWorkItem(out workerThread, out workItem, true)) { return true; } } this.ActivateWorkerThread(workerThread, workItem); return true; } public List<ReleaseThreadsRecord> GetReleaseThreadsRecords() { lock (this._lockObject) { List<ReleaseThreadsRecord> list = new List<ReleaseThreadsRecord>(this._releaseThreadsRecords.Count); foreach (var releaseThreadsRecord in this._releaseThreadsRecords) { list.Add(releaseThreadsRecord); } return list; } } /// <summary> /// 该方法必须在 locked 下执行 /// </summary> /// <param name="workerThread"></param> /// <param name="workItem"></param> /// <param name="workerThreadCall">是不是当前池内的线程调用该方法</param> /// <returns></returns> bool TryGetWorkerThreadAndWorkItem(out WorkerThread workerThread, out WorkItem workItem, bool workerThreadCall) { workerThread = null; workItem = null; if (this._workQueue.Count > 0) { if (this._freeTreads.Count > 0) { workerThread = this._freeTreads.Dequeue(); workItem = this._workQueue.Dequeue(); this._workingTreads.Add(workerThread); return true; } else { if (this._allThreads.Count < this._threads) { workerThread = new WorkerThread(); workItem = this._workQueue.Dequeue(); this._allThreads.Add(workerThread); this._workingTreads.Add(workerThread); return true; } return false; } } else { if (!workerThreadCall) return false; double t = this._keepAliveTime; if (t < 0) { this._workQueue.TrimExcess(); return false; } //此代码块只有当前池内的线程完成工做了之后访问到，从 QueueWorkItem 方法调用该方法是不会执行此代码块的，由于 this.workQueue.Count > 0 if (this._freeTreads.Count == this._allThreads.Count && this._workingTreads.Count == 0 && this._freeTreads.Count > 0) { /* *能执行到这，说明池内没有了任何任务，而且是最后一个活动线程执行完毕 *此时从池中取出一个线程来执行 Tick 方法 */ DateTime now = DateTime.Now; int threadId = Thread.CurrentThread.ManagedThreadId; if (this._allThreads.Any(a => a.ThreadId == threadId))//既然只有当前池内的线程能访问到这，这句判断是否是有点多余了- - { workerThread = this._freeTreads.Dequeue();//弹出一个 WorkerThread 对象，此时不需将弹出的 WorkerThread 对象放入 workingTreads 队列中，由于该对象是供池内自身计时用，相对外界是不知道的，保证外界调用 GetAvailableThreads 方法能获得一个合理的结果 workItem = new WorkItem((state) => { this.Tick((WorkerThread)state); }, workerThread); this._spin = true; try { this._releaseTime = now.AddMilliseconds(t);//设置待释放线程的时间点 } catch (ArgumentOutOfRangeException) { this._releaseTime = DateTime.MaxValue; } return true; } } return false; } } void ActivateWorkerThread(WorkerThread workerThread, WorkItem workItem) { workerThread.SetWork(workItem.Execute); workerThread.Complete += this.WorkComplete; workerThread.Activate(); } void WorkComplete(WorkerThread workerThread) { //避免没法调用终结器，务必将 this.WorkComplete 从 workerThread.Complete 中移除，取出 workerThread 的时候再加上 workerThread.Complete -= this.WorkComplete; if (this._disposed) return; WorkerThread nextWorkerThread = null; WorkItem nextWorkItem = null; lock (this._lockObject) { if (this._disposed) return; this._workingTreads.Remove(workerThread); this._freeTreads.Enqueue(workerThread); this.AdjustPool(); if (!this.TryGetWorkerThreadAndWorkItem(out nextWorkerThread, out nextWorkItem, true)) { return; } } this.ActivateWorkerThread(nextWorkerThread, nextWorkItem); } /// <summary> /// 该方法必须在 locked 下执行 /// </summary> void AdjustPool() { while (this._allThreads.Count > this._threads && this._freeTreads.Count > 0) { WorkerThread workerThread = this._freeTreads.Dequeue(); this._allThreads.Remove(workerThread); workerThread.Dispose(); } } /// <summary> /// 自旋计时，直到收到中止自旋的消息或者达到了释放池内的线程时刻 /// </summary> /// <param name="workerThread"></param> void Tick(WorkerThread workerThread) { DateTime releaseTimeTemp = this._releaseTime; while (true) { lock (this._lockObject) { if (!this._spin) { //spin==false,即说明收到了中止计时的通知 break; } if (DateTime.Now >= releaseTimeTemp) { //此时中止计时，开始释放线程，在释放线程前先把以前加上的 WorkComplete 给取消，这样就不会执行 WorkComplete 方法了，循环终止后 当前线程也天然执行完毕 workerThread.Complete -= this.WorkComplete; //释放全部的线程，也包括当前线程 this.ReleaseThreads(); this._spin = false; //对于运行到这里，由于全部的线程已经被释放（包括当前线程），因此运行完这个方法，当前线程也天然运行结束了 break; } } Thread.SpinWait(1); } } void ReleaseThreads() { ReleaseThreadsRecord releaseThreadsRecord = new ReleaseThreadsRecord(DateTime.Now); foreach (WorkerThread thread in this._allThreads) { try { thread.Dispose(); } catch { } releaseThreadsRecord.ThreadIds.Add(thread.ThreadId); } releaseThreadsRecord.ThreadIds.TrimExcess(); this._releaseThreadsRecords.Add(releaseThreadsRecord); this._allThreads.Clear(); this._freeTreads.Clear(); this._workingTreads.Clear(); this._workQueue.Clear(); this._workQueue.TrimExcess(); } void CheckDisposed() { if (this._disposed) throw new ObjectDisposedException(this.GetType().Name); } /// <summary> /// 销毁当前对象资源，调用此方法会强制终止池内的全部线程 /// </summary> public void Dispose() { if (this._disposed) return; //释放全部线程 lock (this._lockObject) { if (this._disposed) return; this.ReleaseThreads(); this._threads = 0; this._disposed = true; } this.Dispose(true); GC.SuppressFinalize(this); } /// <summary> /// /// </summary> /// <param name="disposing"></param> protected virtual void Dispose(bool disposing) { } class WorkItem { bool _executed = false; WaitCallback _callback; object _state; public WorkItem(WaitCallback callback, object state) { if (callback == null) throw new ArgumentNullException("callback"); this._callback = callback; this._state = state; } public void Execute() { if (this._executed) throw new Exception("当前 WorkItem 已经执行"); this._executed = true; this._callback(this._state); } } public class ReleaseThreadsRecord { public ReleaseThreadsRecord() { this.ThreadIds = new List<int>(); } public ReleaseThreadsRecord(DateTime releaseTime) { this.ReleaseTime = releaseTime; this.ThreadIds = new List<int>(); } /// <summary> /// 释放时间 /// </summary> public DateTime ReleaseTime { get; set; } /// <summary> /// 被释放线程的 Id 集合 /// </summary> public List<int> ThreadIds { get; set; } public ReleaseThreadsRecord Clone() { ReleaseThreadsRecord record = new ReleaseThreadsRecord(this.ReleaseTime); record.ThreadIds = this.ThreadIds.ToList(); return record; } } }
这个类代码仍是挺多的（貌似有点占篇幅- - ），虽然代码里都加上了注释，但我仍是想给你们简单说说其实现思路以及内部一些核心相关成员，方便你们更快的理解。ide
- _threads：一个类型为 int 的字段。表示当前池的大小
- _allThreads：一个类型为 List<WorkerThread> 的字段。用于存储池内建立的全部 WorkerThread
- _workingTreads：一个类型为 List<WorkerThread> 的字段。用于存储正在执行任务的 WorkerThread
- _freeTreads：一个类型为 Queue<WorkerThread> 的字段。用于存储处于空闲状态的 WorkerThread
- _workQueue：一个类型为 Queue<WorkItem> 的字段。用于存储用户往当前池里塞的全部任务
- SetPoolSize(int threads)：设置线程池大小。这个方法主要作了两件事：1.设置线程池大小，也就是字段 _threads 的值。2.调整线程池内线程。当设置的值小于当前池内的大小时，则释放掉多出的空闲线程；当设置的值大于当前池大小时，若是 _workQueue 队列有待处理的任务的话，会尝试着建立新的 WorkerThread 去执行 _workQueue 队列里的任务，目的就是为了使当前池一直处于满负荷状态。
- bool QueueWorkItem(WaitCallback callback, object state)：向线程池中添加任务。每次调用这个方法，都会将 callback 和 state 封装成一个 WorkItem，而后将封装的 WorkItem 对象放入 _workQueue 队列。而后尝试调用 TryGetWorkerThreadAndWorkItem 方法获取可用的 WorkerThread 以及 _workQueue 队列第一个任务，若是获取成功（即有可用的 WorkerThread 和待处理的 WorkItem），就会将取出的 WorkItem 分配给取出的 WorkerThread 去执行。
- bool TryGetWorkerThreadAndWorkItem(out WorkerThread workerThread, out WorkItem workItem, bool workerThreadCall)：尝试从池内取出一个处于空闲的 WorkerThread 和待处理的 WorkItem。这个方法的实现不是很复杂，若是池内有空闲的 WorkerThread 和待处理的 WorkItem，则返回 true，不然返回 false。目前咱们这个线程池内 WorkerThread 的建立不是伴随线程池建立而建立，而是真正须要用到的时候才会去建立。即当有任务往池里塞的时候，首先会判断 _freeTreads 集合内是否有空闲的 WorkerThread，若是有，则弹出一个空闲的 WorkerThread 去执行任务，同时将弹出的 WorkerThread 添加到 _workingTreads 集合中，没有的话才会去建立新的 WorkerThread 去执行任务，同时也会将新建的 WorkerThread 添加到 _workingTreads 集合中。
- ActivateWorkerThread(WorkerThread workerThread, WorkItem workItem)：这个方法体内的实现很简单，就是将 workItem 分配给 workerThread，同时调用 workerThread.Activate() 激活线程执行任务，调用 workerThread.Activate()会将当前池内的方法 WorkComplete(WorkerThread workerThread) 绑定到 workerThread 定义的 Complete 事件上，每当 workerThread 执行完任务之后，都会触发 workerThread.Complete 事件，以通知其所在的线程池。
- WorkComplete(WorkerThread workerThread)：每当 workerThread 执行完任务之后，都会调用该方法。该方法参数是一个 WorkerThread 对象，也就是说每一个 workerThread 执行完任务后都会将本身做为参数调用这个方法。在这个方法内主要是作三件事：1.将执行完任务的 workerThread 从 _workingTreads 集合中移除，而后将 workerThread 添加到空闲线程队列 _freeTreads 中。2.调整线程池线程（若是有必要的话），为何在这要进行调整线程池呢？由于会出现这种状况，好比当前线程池大小是 10，正在工做的线程为 6 个，空闲线程也就是 4 个，这时候咱们调用 SetPoolSize(5)，也就是将线程池大小设置为 5，减小了线程池的容量，虽然在 SetPoolSize 方法内会调整了一遍线程池大小，但 SetPoolSize 方法内只会销毁掉空闲的线程，也就是 4 个空闲线程会被销毁，这时候池内其实仍是存在 6 个线程。因此还须要销毁一个，这时候怎么办呢？不可能在 SetPoolSize 方法内把正在执行任务的线程给终止掉吧？所以，workerThread 每次执行完任务后都要执行一次调整线程池的操做，以保证池内的线程数量是正确的。3.调用 TryGetWorkerThreadAndWorkItem 方法，若是有待处理的任务的话，则继续处理下一个任务，这样就达到了持续处理 _workQueue 队列内任务的目的。
上面就是 WorkerThreadPool 的一些核心字段以及方法，至于其它的成员就不作详细说明了。 为了方便管理，池内用了 _freeTreads 和 _workingTreads 两个集合来维护池内线程状态。因此每次从空闲线程 _freeTreads 取出 workerThread 执行任务的时候，都必须将 workerThread 添加到 _workingTreads 集合中；每一个 workerThread 执行完任务都会将本身从 _workingTreads 移除，同时将本身置为空闲线程添加到 _freeTreads 集合中等待接受下一个任务来临，因此 WorkComplete 方法体内最后都要调用 TryGetWorkerThreadAndWorkItem 方法获取可用的 WorkerThread 以及一个待处理的任务，而后执行，这样就造成了一个循环，只要有任务，池内就会一直处于满负荷状态。性能
开篇提到一个需求：没有爬取任务的时候，须要减小甚至清空池内的全部线程，以避免池内线程一直挂着占用系统资源。所以我给 IThreadPool 加了一个属性：KeepAliveTime。经过这个属性，能够给线程池设定一个时间，即线程池在指定的时间内都没有接收到任何任务，则会自行将池内的线程给销毁。在 WorkerThreadPool 中这个功能的实现很简单，在最后一个任务被执行完了之后，会自动从池内取出一个空闲的 workerThread 执行计时操做，也就是 WorkerThreadPool.Tick 方法，其实现也就是自旋计时，若是过了指定时间后都没有接受到任务，则自动将池内的线程给销毁。这个计时实现很简陋- - ，技术有限，想不到其它好办法了。学习
咱们的这个线程池设计简单，功能不是很强，但很适合咱们如今的程序，至少让我用的安心。目前已经在服务器上跑了一年半，一切都很正常。小程进入园子已有3年，在这么好的平台上小程一直都只知道汲取，却从未想过回报。所以，我想给你们分享点东西，虽然这个 WorkerThreadPool 简单，没什么高深的技术，但也算是个小结晶。若是你们有好建议，小程将万分感谢！网站
第一次写博，好紧张！最后，感谢博客园提供了这么一个良好的学习平台！
相关文章
- 1. 自制线程池4
- 2. 自制线程池３续
- 3. 自制线程池３
- 4. .NET多线程编程（4）——线程池
- 5. Nutshell.ThreadWorkerPool .Net线程池设计
- 6. .NET线程池最大线程数的限制-记一次IIS并发瓶颈
- 7. C#并行编程（2）：.NET线程池
- 8. Java 线程池技术之一 自实现线程池
- 9. 线程的控制和线程池
- 10. spring 线程池 的一个坑。
- 更多相关文章...
- • 第一个MyBatis程序 - MyBatis教程
- • 第一个Hibernate程序 - Hibernate教程
- • 漫谈MySQL的锁机制
- • Git五分钟教程
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 自制线程池4
- 2. 自制线程池３续
- 3. 自制线程池３
- 4. .NET多线程编程（4）——线程池
- 5. Nutshell.ThreadWorkerPool .Net线程池设计
- 6. .NET线程池最大线程数的限制-记一次IIS并发瓶颈
- 7. C#并行编程（2）：.NET线程池
- 8. Java 线程池技术之一 自实现线程池
- 9. 线程的控制和线程池
- 10. spring 线程池 的一个坑。