[.NET] 自己实现任务池（模仿线程池）

线程池虽然好用，但限制也不少：

（1）总觉得默认的 MaxThread 小了一点，每次使用都要手工调大= =

（2）任务不能等待完成

（3）任务一旦加入不能取消，甚至不知道是正在排队/正在执行/执行完毕

（4）最恶心的一点，全是 MTAThread，好多COM都不能用。ClipBoard、WebBrowser ...

实在不能忍了，自己写了个“任务池”，模拟线程池的功能。不同点有：

（1）没有数量上限，新进的任务不需要排队（但任务太多可能影响系统性能）

（2）任务的创建和开始可以分开，也可以创建时就开始。

（3）任务可等待

（4）任务可强制取消，虽然非常非常非常非常非常不建议这么做，这可能造成不可预知的问题

（5）可以选择任务线程的 ApartmentState （MTA / STA / Unknown = 无所谓）

相同点在于：

（1）保证（近乎绝对的）线程安全，逻辑上没有线程不安全的地方

（2）线程可重用

不足之处在于：

（1）还是应该添加限制线程数目的功能，避免对系统性能造成太大影响

（2）任务应该支持“尝试取消”操作

（3）有些 TTask 类里的字段应该对用户只读，但语法上实在做不到= =（没有 friend 关键字）

Version 1.0

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Net.Mime;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;

 // ReSharper Disable InconsistentNaming

 namespace Efficiency.Core {

     //+ delegate TTaskDelegate
     public delegate void TTaskDelegate(TTask task, object param);

     //+ class TTask
     public class TTask {

         public readonly AutoResetEvent Event = new AutoResetEvent(false);
         public readonly ApartmentState ApartmentState;

         public readonly TTaskDelegate Callback;
         public readonly object Param;

         public Thread Thread { get; set; }

         //-- .ctor()
         public TTask(TTaskDelegate callback, object param, ApartmentState state)
         {
             this.ApartmentState = state;
             this.Param = param;
             this.Callback = callback;
         }

         public int Status = ;
         // 0: Working...
         // 1: Marked Finished
         // 2: Marked Force Exited
         public bool IsFinished => (this.Status != );

         public bool Wait(int timeout = -) => this.Event.WaitOne(timeout);

         //-- void ForceExit()
         public void ForceExit()
         {
             if (Interlocked.CompareExchange(ref this.Status, , ) != ) return;
             try {
                 this.Thread.Abort();
             }
             catch {
                 // Ignored
             }
         }

         //-- void ForceExit(out Exception)
         public bool ForceExit(out Exception exception)
         {
             exception = null;
             if (Interlocked.CompareExchange(ref this.Status, , ) != ) return true;
             try {
                 this.Thread.Abort();
                 return true;
             }
             catch(Exception ex) {
                 exception = ex;
                 return false;
             }
         }
     } // class TTask

     //+ class TTaskPool
     public static class TTaskPool {

         //+ class TTaskPool.TTaskThreadContext
         private class TTaskThreadContext {
             public static volatile int CanExit = ;

             public readonly AutoResetEvent WaitEvent = new AutoResetEvent(false);
             public readonly Queue<Thread> ThreadQueue;
             public TTask Task;

             //-- .ctor()
             public TTaskThreadContext(Queue<Thread> threadQueue, TTask task)
             {
                 this.ThreadQueue = threadQueue;
                 this.Task = task;
             }

         } // class TTaskPool.TTaskThreadContext

         private static readonly Queue<Thread> m_STAQueue = new Queue<Thread>();
         private static readonly ReaderWriterLock m_STARWLock = new ReaderWriterLock();
         private static readonly Dictionary<Thread, TTaskThreadContext> m_STAContext =
             new Dictionary<Thread, TTaskThreadContext>();

         private static readonly Queue<Thread> m_MTAQueue = new Queue<Thread>();
         private static readonly ReaderWriterLock m_MTARWLock = new ReaderWriterLock();
         private static readonly Dictionary<Thread, TTaskThreadContext> m_MTAContext =
             new Dictionary<Thread, TTaskThreadContext>();

         private static int s_PeakSTATaskCount = ;
         public static int PeakSTATaskCount => s_PeakSTATaskCount;

         private static int s_PeakMTATaskCount = ;
         public static int PeakMTATaskCount => s_PeakMTATaskCount;

         public static int PeakTaskCount => PeakMTATaskCount + PeakSTATaskCount;

         //-- TTask CreateTask(TTaskDelegate, object)
         [MethodImpl(0x100)]
         public static TTask CreateTask(
             TTaskDelegate callback,
             object param = null,
             ApartmentState state = ApartmentState.Unknown)
         {
             if (callback == null) {
                 throw new ArgumentNullException(nameof(callback));
             }
             return new TTask(callback, param, state);
         }

         //-- bool TryInsertTask(TTask, ThreadQueue<Thread>, Dictionary<Thread, TTaskThreadContext>, ReaderWriterLock)
         [MethodImpl(0x100)]
         private static bool TryInsertTask(
             TTask task,
             Queue<Thread> queue,
             Dictionary<Thread, TTaskThreadContext> dict,
             ReaderWriterLock rwlock,
             ApartmentState state,
             bool force)
         {
             Thread thread = null;
             TTaskThreadContext context;
             bool isNew;
             lock (queue) {
                 if (queue.Count == ) {
                     if (! force) return false;
                     isNew = true;
                 }
                 else {
                     thread = queue.Dequeue();
                     isNew = false;
                 }
             }

             if (isNew) {
                 thread = new Thread(TTaskThreadRoutine);
                 thread.SetApartmentState(state);
                 thread.IsBackground = true;
                 if (state == ApartmentState.STA)
                     Interlocked.Increment(ref s_PeakSTATaskCount);
                 else
                     Interlocked.Increment(ref s_PeakMTATaskCount);

                 context = new TTaskThreadContext(queue, task);
                 rwlock.AcquireWriterLock(-);
                 dict.Add(thread, context);
                 rwlock.ReleaseWriterLock();
                 thread.Start(context);
             }
             else {
                 rwlock.AcquireReaderLock(-);
                 context = dict[thread];
                 rwlock.ReleaseReaderLock();
                 context.Task = task;
                 context.WaitEvent.Set();
             }

             return true;
         }

         //-- void InsertTask(TTask)
         public static void InsertTask(TTask task)
         {
             if (task == null) {
                 throw new ArgumentNullException(nameof(task));
             }

             switch (task.ApartmentState) {
             case (ApartmentState.STA):
                 TryInsertTask(task, m_STAQueue, m_STAContext, m_STARWLock, ApartmentState.STA, true);
                 break;

             case (ApartmentState.MTA):
                 TryInsertTask(task, m_MTAQueue, m_MTAContext, m_MTARWLock, ApartmentState.MTA, true);
                 break;

             default:
                 if (TryInsertTask(task, m_MTAQueue, m_MTAContext, m_MTARWLock, ApartmentState.MTA, false)) return;
                 if (TryInsertTask(task, m_STAQueue, m_STAContext, m_STARWLock, ApartmentState.STA, false)) return;
                 TryInsertTask(task, m_MTAQueue, m_MTAContext, m_MTARWLock, ApartmentState.MTA, true);
                 break;
             }

         }

         //-- TTask CreateInsertTask(STATaskDelegate, object, ApartmentState)
         [MethodImpl(0x100)]
         public static TTask CreateInsertTask(
             TTaskDelegate callback,
             object param = null,
             ApartmentState state = ApartmentState.Unknown)
         {
             if (callback == null) {
                 throw new ArgumentNullException(nameof(callback));
             }
             TTask task = new TTask(callback, param, state);
             InsertTask(task);
             return task;
         }

         //-- void TTaskThreadRoutine(object)
         private static void TTaskThreadRoutine(object threadContext)
         {
             TTaskThreadContext context = (TTaskThreadContext)threadContext;
             Thread thisThread = Thread.CurrentThread;
             while (true) {
                 if (TTaskThreadContext.CanExit != ) return;
                 thisThread.Priority = ThreadPriority.Normal;

                 TTask task = context.Task;
                 task.Callback.Invoke(task, task.Param);
                 task.Thread = thisThread;
                 thisThread.IsBackground = true;

                 task.Event.Set();
                 if (Interlocked.CompareExchange(ref task.Status, , ) == ) {
                     try {
                         thisThread.Abort();
                     }
                     catch {
                         // Ignored
                     }
                 }
                 if (TTaskThreadContext.CanExit != ) return;

                 lock (context.ThreadQueue) {
                     context.ThreadQueue.Enqueue(thisThread);
                 }
                 context.WaitEvent.WaitOne(-);
             }
         }

     } // class TTaskPool

 } // namespace Efficiency.Core