多线程实现

WorkState

    public enum WorkState
    {
        Ready,
        Running,
        Completed
    }

IWork

    public interface IWork
    {
        WorkState State { get; set; }
        void Perform();
    }

关键类WorkQueue

public class WorkQueue
    {
        private List<IWork> _vlstWork = new List<IWork>();

        public void Add(IWork work)
        {
            lock (this)
            {
                _vlstWork.Add(work);
            }
        }

        public int GetCount(WorkState state)
        {
            lock (this)
            {
                int count = 0;
                _vlstWork.ForEach(item =>
                {
                    if (item.State == state)
                        count++;
                });
                return count;
            }
        }

        public IWork GetWork()
        {
            lock(this)
            {
                foreach (IWork work in _vlstWork)
                    if (work.State == WorkState.Ready)
                        return work;
                return null;
            }
        }
    }

重点类ThreadScheduler

public delegate void AllFinishedHandler();
    public class ThreadScheduler
    {
        private readonly int _viConcurrentLimit = 10;
        private WorkQueue _vWorkQueue = null;

        public AllFinishedHandler OnAllFinished = null;

        public WorkQueue WorkQueue
        {
            get { return _vWorkQueue; }
        }
        public int ConcurrentLimit
        {
            get { return _viConcurrentLimit; }
        }

        public ThreadScheduler():this(new WorkQueue(),10) { }
        public ThreadScheduler(WorkQueue workQueue):this(workQueue,10){ }
        public ThreadScheduler(int concurrent) : this(new WorkQueue(),concurrent) { }
        public ThreadScheduler(WorkQueue workQueue,int concurrent)
        {
            _vWorkQueue = workQueue;
            _viConcurrentLimit = concurrent;
        }

        public void StartWork()
        {
            CheckAllFinished();

            while (_vWorkQueue.GetCount(WorkState.Ready) > 0)
            {
                System.Diagnostics.Trace.WriteLine(_vWorkQueue.GetCount(WorkState.Ready));
                if (_vWorkQueue.GetCount(WorkState.Running) < _viConcurrentLimit)
                {
                    IWork work = _vWorkQueue.GetWork();
                    work.State = WorkState.Running;
                    if (work != null)
                    {
                        System.Threading.Thread thread = new System.Threading.Thread(() => {
                            work.Perform();
                            work.State = WorkState.Completed;
                        });
                        thread.IsBackground = true;
                        thread.Start();
                    }
                }
            }
        }

　　  //这里要是用 一个volatile变量 来实现更准确的测试完成时间。不需要新起来一个线程啊！当然这个方法的调用位置需要修改。

        private void CheckAllFinished()
        {
            System.Threading.Thread thread = new System.Threading.Thread(() => {
                while (_vWorkQueue.GetCount(WorkState.Running) + _vWorkQueue.GetCount(WorkState.Ready) > 0)
                {
                    System.Threading.Thread.Sleep(50);
                }
                if (OnAllFinished != null)
                    OnAllFinished();
            });
            thread.IsBackground = true;
            thread.Start();
        }

    }

 测试类TestWork

public class TestWork : IWork
    {
        private string _vsName = string.Empty;
        private static int _viIndex = 1;
        private WorkState _vState = WorkState.Ready;

        public WorkState State
        {
            get { return _vState; }
            set { _vState = value; }
        }

        public TestWork() { }
        public TestWork(string name)
        {
            _vsName = name;
        }

        public void Perform()
        {
            Console.WriteLine("{0}.{1}--------Thread:{2}",_viIndex++,_vsName,System.Threading.Thread.CurrentThread.Name);
        }
    }

看看 效果：

class Program
    {
        static void Main(string[] args)
        {
            List<string> list = new List<string>();// new List<string>(new string[] { "Sunday", "Monday", "Tuesday", "Wednesday" });

            #region Test One
            /*
            int count = 2;
            System.Threading.Thread[] threadArray = new System.Threading.Thread[count];
            for (int i = 0; i < count; i++)
            {
                threadArray[i] = new System.Threading.Thread(new TestWork(list[i]).Perform);
                threadArray[i].Name = string.Format("WT#{0}", i);
                threadArray[i].IsBackground = true;
            }

            foreach (System.Threading.Thread thread in threadArray)
            {
                thread.Start();
            }
            */
            #endregion

            Random random=new Random();
            for (int i = 0; i < 10000; i++)
            {
                list.Add(random.Next(10000).ToString());
            }

            DateTime startDateTime = DateTime.Now;
            Console.WriteLine("There are {0} works as follows:", list.Count);
            ThreadScheduler vThreadScheduler = new ThreadScheduler(8000);
            list.ForEach(item=>{
                vThreadScheduler.WorkQueue.Add(new TestWork(item));
            });
            vThreadScheduler.OnAllFinished += () =>
            {
                DateTime endDateTime=DateTime.Now;
                Console.WriteLine("Works:{3},Used Time={0} <--- {1}-{2}",
                        endDateTime-startDateTime,endDateTime.ToString(),
                        startDateTime.ToString(),
                        vThreadScheduler.ConcurrentLimit
                    );
            };
            vThreadScheduler.StartWork();

            Console.WriteLine("Over");
            Console.Read();
        }
    }

测试发现当thread数量为任务数量一半的时候比80%要 快，比100%更快。当然这里的任务是小任务。

 源码下载