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);
    }
}