Extended Thread Pool(可扩展的线程池)

Extended Thread Pool 的特征

• IoC 支持（使用了 Unity ）
• 扩展队列
• 扩展任务项
• 限制了工作线程的最大数量
• 动态线程分配
• 线程优先级支持
• 扩展日志

Extended Thread Pool 的设计

• ITaskItem 表示任务
• ITaskQueue 表示任务的队列逻辑
• ITaskQueueController 表示消费者和生产者之间的通信逻辑（线程安全）
• WorkThread 表示线程执行
• ExtendedThreadPool 控制线程的执行

让我们来深入了解每个类：

• ITaskItem 表示要完成工作
• 1.   public   interface  ITaskItem
  2.  {
  3.        ThreadPriority Priority {  get ; }
  4.         void  DoWork();
  5.   }
• ThreadPriority – WorkThread 的优先级，可以在每个任务中指定
• ITaskQueue 另一个管理任务队列的接口
• 1.      public   interface  ITaskQueue
  2.     {
  3.          int  Count {  get ; }
  4.          void  Enqueue(ITaskItem item);
  5.         ITaskItem Dequeue();
  6.     }
• • ITaskQueueController 提供了消费者和生产者之间的通信逻辑
  • 1.      public   interface  ITaskQueueController : IDisposable
    2.     {
    3.          int  ConsumersWaiting {  get ; }
    4.          void  Enqueue(ITaskItem item);
    5.         ITaskItem Dequeue();
    6.     }

从 ITaskQueueController 接口派生了两个队列控制对象：

• DefaultTaskQueueController
• BoundedTaskQueueController

Default Task Queue Controller

 

DefaultTaskQueueController 对与 ITaskQueue 是线程安全的封装：

1. public   class  DefaultTaskQueueController : TaskQueueControllerBase
2. {
3.      public  DefaultTaskQueueController(ITaskQueue taskQueue)
4.         :  base (taskQueue)
5.     {
6.     }
8.     #region Overrides of TaskQueueControllerBase
10.      public   override   void  Enqueue(ITaskItem item)
11.     {
12.          lock  (_locker)
13.         {
14.             _taskQueue.Enqueue(item);
15.              if  (_consumersWaiting > 0)
16.                 Monitor.PulseAll(_locker);
17.         }
18.     }
20.      public   override  ITaskItem Dequeue()
21.     {
22.         ITaskItem taskItem;
23.          lock  (_locker)
24.         {
25.              while  (_taskQueue.Count == 0 && !_isDispose)
26.             {
27.                 _consumersWaiting++;
28.                 Monitor.Wait(_locker);
29.                 _consumersWaiting--;
30.             }
31.              if  (_isDispose)
32.                  return   null ;
33.             taskItem = _taskQueue.Dequeue();
34.         }
35.          return  taskItem;
36.     }
38.     #endregion
39. }

Bounded Task Queue Controller

BoundedTaskQueueController （线程安全）如果生产者任务或者创建项的任务比消费者的处理速度快，系统将会无限的消耗内存。 BoundedTaskQueueController 允许限制队列的大小来限制生产者的越界。  

1. public   class  BoundedTaskQueueController : TaskQueueControllerBase
2. {
3.      private   readonly   int  _maxTasksCount;
4.      private   int  _producersWaiting;
6.      public  BoundedTaskQueueController(ITaskQueue taskQueue,  int  maxTasksCount)
7.         :  base (taskQueue)
8.     {
9.          if  (maxTasksCount < 1)
10.              throw   new  ArgumentException( "MaxTasksCount should be greater 0" );
11.         _maxTasksCount = maxTasksCount;
12.     }
14.      public   override   void  Enqueue(ITaskItem item)
15.     {
16.          lock  (_locker)
17.         {
18.              while  (_taskQueue.Count == (_maxTasksCount - 1) && !_isDispose)
19.             {
20.                 _producersWaiting++;
21.                 Monitor.Wait(_locker);
22.                 _producersWaiting--;
23.             }
24.             _taskQueue.Enqueue(item);
25.              if  (_consumersWaiting > 0)
26.                 Monitor.PulseAll(_locker);
27.         }
28.     }
30.      public   override  ITaskItem Dequeue()
31.     {
32.         ITaskItem taskItem;
33.          lock  (_locker)
34.         {
35.              while  (_taskQueue.Count == 0 && !_isDispose)
36.             {
37.                 _consumersWaiting++;
38.                 Monitor.Wait(_locker);
39.                 _consumersWaiting--;
40.             }
41.              if  (_isDispose)
42.                  return   null ;
43.             taskItem = _taskQueue.Dequeue();
44.              if  (_producersWaiting > 0)
45.                 Monitor.PulseAll(_locker);
46.         }
47.          return  taskItem;
48.     }
49. }

Extended Thread Pool

 

ExtendedThreadPool 类管理接口 ITaskQueueController 。 AddTask 方法用来添加任务到任务通道中去。如果最大的线程限制未达到并且 ConsamersWaitin = 0 ， WorkThread 类的新实例将被创建。  

1. public   void  AddTask(ITaskItem item)
2. {
3.      if  (item.IsNull())
4.          throw   new  ArgumentNullException( "item" );
5.      if  (!(Enum.IsDefined( typeof  (ThreadPriority), item.Priority)))
6.          throw   new  ArgumentException( "priority" );
7.     TaskQueueController.Enqueue(item);
8.      if  (IsStartNewWorker())
9.         CreateWorkThread();
10. }

Work Thread

 

WorkThread 类，执行任务项和提供日志记录的。  

1. public   void  Start()
2. {
3.      while  (_isRun)
4.     {
5.          try
6.         {
7.             ITaskItem item = _taskQueueController.Dequeue();
8.              if  (item.IsNull())
9.                  continue ;
10.             DoWork(item);
11.         }
12.          catch  (Exception ex)
13.         {
14.             _logger.Error(ex.Message);
15.         }
16.     }
17. }

Thread Pool Extensibility

 

ExtendedThreadPool 类提供了 Ioc 支持， ITaskQueueController 接口标记了 Dependency 属性。  

1. [Dependency]
2. public  ITaskQueueController TaskQueueController {  private   get ;  set ; }

如果你需要更加强大的任务队列，就必须实现 ITaskQueue 接口，并不需要担心线程安全的问题；也可以创建 ITaskQueueController 。我使用 Unity 来配置 ExtendedThreadPool 。

 

 

 

 

例子

 

在其中一个项目中，我使用了 multi-threading 进行 MSMQ 交互。 SampleTask 派生了接口 ITaskItem ，可以从项目 CoreDefaultMsmqSample 中了解详情。  

1. public   void  DoWork()
2. {
3.      using  (var transaction =  new  MessageQueueTransaction())
4.     {
5.          try
6.         {
7.             transaction.Begin();
8.             Message msmqMessage = 
9.               _queue.Receive(TimeSpan.FromMilliseconds(500), transaction);
10.              if  (msmqMessage !=  null )
11.             {
12.                 var message = (ExternalMessage) msmqMessage.Body;
13.                 LogManager.GetLogger(GetType()).Info( "Task has been "  + 
14.                             "done, info {0}" .FormatWith(message.Data));
15.                  //Do work
16.                 Thread.Sleep(1000);
17.             }
18.         }
19.          catch  (Exception ex)
20.         {
21.             transaction.Abort();
22.             LogManager.GetLogger(GetType()).Error(ex.Message);
23.              return ;
24.         }
25.         transaction.Commit();
26.     }
27. }

总结

作者考虑到了线程池的可配置性和扩展性,在引用这些代码后,写出的线程应用会非常简洁,且不需要考虑线程之间的复杂操作.如果,你觉得有写模块是你 不需要的,比如日志模块或者IoC模块(这是什么模块我也不清楚),可以自行把代码删除掉,希望原作者会继续他的思路完善这个框架.