C#多线程服务，控制最大线程并发和最小线程并发

using System;
using System.Threading;

namespace ThreadTest
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                TestDemo manager = new TestDemo();
                manager.MinThreadNumber = 1;
                manager.MaxThreadNumber = 1;

                while (true)
                {
                    manager.Main();

                    //服务3秒执行一次
                    Thread.Sleep(1000);
                    Console.WriteLine(3);
                    Thread.Sleep(1000);
                    Console.WriteLine(2);
                    Thread.Sleep(1000);
                    Console.WriteLine(1);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;

namespace ThreadTest
{
    public class TestDemo : ThreadFactory<UserInfo>
    {
        private static int index = 0;
        private IList<UserInfo> GetList()
        {
            IList<UserInfo> list = new List<UserInfo>();
            for (var i = 0; i < 50; i++)
            {
                list.Add(new UserInfo
                {
                    Id = ++index,
                    Name = "Name" + index
                });
                if (index == 500)
                    break;
            }
            return list;
        }

        public void Main()
        {
            index = 0;
            var list = GetList();
            Stopwatch sw = new Stopwatch();
            sw.Start();
            while (list != null && list.Count > 0)
            {
                Execute(list);
                list = GetList();
            }
            sw.Stop();
            Console.WriteLine($"单线程需要耗时{(index * 1000 / 1000)}秒");
            Console.WriteLine($"执行完成 耗时{(sw.ElapsedMilliseconds / 1000)}秒");
        }

        protected override void Process(UserInfo info)
        {
            //处理这个方法至少1秒
            Thread.Sleep(1000);
            int threadId = Thread.CurrentThread.ManagedThreadId;
            Console.WriteLine($"ThreadId={threadId} Id={info.Id}  Name={info.Name}");
        }
    }

    /// <summary>
    /// 用户类
    /// </summary>
    public class UserInfo
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace ThreadTest
{
    public abstract class ThreadFactory<T>
    {
        private AutoResetEvent wait_sync = new AutoResetEvent(false); // 用来控制：并发最大个数线程max_thread_number 
        private AutoResetEvent wait_main = new AutoResetEvent(false); // 用来控制：主程序的结束执行，当所有任务线程执行

        private int min_thread_number = 1;      //设置并行最小线程个数
        private int max_thread_number = 5;      //设置并行最大线程个数
        private int total_thread_number = 0;    //用来控制：主程序的结束执行，当所有任务线程执行完毕
        private bool _isAlive = false;

        /// <summary> 设置并行最小线程个数 </summary>
        public int MinThreadNumber
        {
            get { return min_thread_number; }
            set
            {
                min_thread_number = value;
                //设置最小线程线程个数
                ThreadPool.SetMinThreads(min_thread_number, min_thread_number);
            }
        }
        /// <summary> 设置并行最大个线程个数 </summary>
        public int MaxThreadNumber
        {
            get { return max_thread_number; }
            set
            {
                max_thread_number = value;
                //设置最大线程个数
                ThreadPool.SetMaxThreads(max_thread_number, max_thread_number);
            }
        }

        public void Execute(IList<T> list)
        {
            for (var i = 0; i < list.Count; i++)
            {
                if (total_thread_number >= max_thread_number)
                    wait_sync.WaitOne();

                var j = i;
                Task.Factory.StartNew(() =>
                {
                    var info = list[j];
                    Process(info);
                    total_thread_number--;

                    if (total_thread_number < max_thread_number)
                        wait_sync.Set();// 任务线程，继续执行
                    if (j + 1 == list.Count)
                        wait_main.Set(); // 主程序线程，继续执行
                });
                total_thread_number++;
            }
            wait_main.WaitOne();
        }

        protected abstract void Process(T t);
    }
}