--近期有一个需要运用多线程的项目，会有并发概率，所以写了一份代码，可能有写地方还不完善，后续有需求在改
 1     /// <summary>

     /// 并发对象

     /// </summary>

     public class MeterAsyncQueue

     {

         public MeterAsyncQueue()

         {

             MeterInfoTask = new MeterInfo();

         }

         public MeterInfo MeterInfoTask { get; set; }

     }

     public class MeterInfo

     {

         public MeterInfo()

         {

         }

         public int Id { get; set; }

     }

     /// <summary>

     /// 线程通用类

     /// </summary>

     public class TaskCommand

     {

         CancellationTokenSource tokenSource = new CancellationTokenSource();

         ManualResetEvent resetEvent = new ManualResetEvent(true);

         Thread thread = null;

         /// <summary>

         /// 开始任务

         /// </summary>

         public void StartData()

         {

             tokenSource = new CancellationTokenSource();

             resetEvent = new ManualResetEvent(true);

             List<int> Ids = new List<int>();

             for (int i = ; i < ; i++)

             {

                 Ids.Add(i);

             }

             thread = new Thread(new ThreadStart(() => StartTask(Ids)));

             thread.Start();

         }

         /// <summary>

         /// 暂停任务

         /// </summary>

         public void OutData()

         {

             //task暂停

             resetEvent.Reset();

         }

         /// <summary>

         /// 继续任务

         /// </summary>

         public void ContinueData()

         {

             //task继续

             resetEvent.Set();

         }

         /// <summary>

         /// 取消任务

         /// </summary>

         public void Cancel()

         {

             //释放对象

             resetEvent.Dispose();

             foreach (var CurrentTask in ParallelTasks)

             {

                 if (CurrentTask != null)

                 {

                     if (CurrentTask.Status == TaskStatus.Running) { }

                     {

                         //终止task线程

                         tokenSource.Cancel();

                     }

                 }

             }

             thread.Abort();

         }

         /// <summary>

         /// 执行数据

         /// </summary>

         /// <param name="Index"></param>

         public void Execute(int Index)

         {

             //阻止当前线程

             resetEvent.WaitOne();

             Console.WriteLine("当前第" + Index + "个线程");

             Thread.Sleep();

         }

         //队列对象

         private Queue<MeterAsyncQueue> AsyncQueues { get; set; }

         /// <summary>

         /// 并发任务数

         /// </summary>

         private int ParallelTaskCount { get; set; }

         /// <summary>

         /// 并行任务集合

         /// </summary>

         private List<Task> ParallelTasks { get; set; }

         //控制线程并行数量

         public void StartTask(List<int> Ids)

         {

             IsInitTask = true;

             ParallelTasks = new List<Task>();

             AsyncQueues = new Queue<MeterAsyncQueue>();

             //获取并发数

             ParallelTaskCount = ;

             //初始化异步队列

             InitAsyncQueue(Ids);

             //开始执行队列任务

             HandlingTask();

             Task.WaitAll(new Task[] { Task.WhenAll(ParallelTasks.ToArray()) });

         }

         /// <summary>

         /// 初始化异步队列

         /// </summary>

         private void InitAsyncQueue(List<int> Ids)

         {

             foreach (var item in Ids)

             {

                 MeterInfo info = new MeterInfo();

                 info.Id = item;

                 AsyncQueues.Enqueue(new MeterAsyncQueue()

                 {

                     MeterInfoTask = info

                 });

             }

         }

         /// <summary>

         /// 是否首次执行任务

         /// </summary>

         private bool IsInitTask { get; set; }

         //锁

         private readonly object _objLock = new object();

         /// <summary>

         /// 开始执行队列任务

         /// </summary>

         private void HandlingTask()

         {

             lock (_objLock)

             {

                 if (AsyncQueues.Count <= )

                 {

                     return;

                 }

                 var loopCount = GetAvailableTaskCount();

                 //并发处理队列

                 for (int i = ; i < loopCount; i++)

                 {

                     HandlingQueue();

                 }

                 IsInitTask = false;

             }

         }

         /// <summary>

         /// 获取队列锁

         /// </summary>

         private readonly object _queueLock = new object();

         /// <summary>

         /// 处理队列

         /// </summary>

         private void HandlingQueue()

         {

             CancellationToken token = tokenSource.Token;

             lock (_queueLock)

             {

                 if (AsyncQueues.Count > )

                 {

                     var asyncQueue = AsyncQueues.Dequeue();

                     if (asyncQueue == null) return;

                     var task = Task.Factory.StartNew(() =>

                     {

                         if (token.IsCancellationRequested)

                         {

                             return;

                         }

                         //阻止当前线程

                         resetEvent.WaitOne();

                         //执行任务

                         Execute(asyncQueue.MeterInfoTask.Id);

                     }, token).ContinueWith(t =>

                     {

                         HandlingTask();

                     }, TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously);

                     ParallelTasks.Add(task);

                 }

             }

         }

         /// <summary>

         /// 获取当前有效并行的任务数

         /// </summary>

         /// <returns></returns>

         [MethodImpl(MethodImplOptions.Synchronized)]

         private int GetAvailableTaskCount()

         {

             if (IsInitTask)

                 return ParallelTaskCount;

             return ;

         }

     }