BuildQueue test

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

namespace BuildQueueTest {

    class Worker {

        protected QueueTask qTask = null;
        protected Boolean stopRequest = false;
        protected BuildQueue queue;
        protected Thread thr;
        private readonly object lockObj = new object();

        public Worker(BuildQueue queue, int id) {
            thr = new Thread(new ThreadStart(run));
            this.queue = queue;
            thr.Name = "Wrk" + id;
        }

        public void Start() {
            thr.Start ();
        }

        public void Join() {
            thr.Join ();
        }

        public void run() {
            while (true) {
                lock (lockObj) {
                    queue.regWaiter (this);
                    if (stopRequest)
                        break;
                    if (qTask == null) {
                        Monitor.Wait (lockObj);
                        if (stopRequest)
                            break;
                    }
                }
                QueueTask cqTask = qTask;
                qTask = null;
                cqTask.execute ();
                queue.release (qTask);
            }
        }

        public void setQueueTask(QueueTask qTask) {
            lock (lockObj) {
                this.qTask = qTask;
                Monitor.Pulse (lockObj);    // notify
            }
        }

        public void stop() {
            lock (lockObj) {
                stopRequest = true;
                Monitor.Pulse (lockObj);
            }
        }

    }

    class QueueTask {

        public void execute() {
            Stopwatch sw = new Stopwatch ();
            sw.Start ();
            while (sw.ElapsedMilliseconds < 3000) {
                // dummy CPU burning loop
            };
            sw.Stop ();
        }

    }

    class BuildQueue {

        protected int numWorkers;
        protected List<Worker> workers = new List<Worker>(), waitingWorkers = new List<Worker>();
        protected Boolean finished = false;
        protected int rc = 0;
        protected List<QueueTask> sortedList = new List<QueueTask> ();  // TODO: use SortedList
        protected readonly object lockObj = new object();

        public BuildQueue(int numWorkers) {
            this.numWorkers = numWorkers;
            waitingWorkers = new List<Worker> ();
        }

        private void feedWorker(QueueTask qTask) {
            Worker worker = waitingWorkers[0];
            waitingWorkers.RemoveAt(0);
            // Console.WriteLine ("feed: Waiting workers=" + waitingWorkers.Count);
            worker.setQueueTask(qTask);
        }

        private void stopWorkers() {
            Console.WriteLine ("stopWorkers");
            foreach(Worker worker in waitingWorkers) {
                worker.stop();
            }
        }

        protected void feedWorkers() {
            if (finished) {
                stopWorkers ();
                return;
            }
            while (waitingWorkers.Count > 0) {
                if (sortedList.Count > 0) {
                    QueueTask qTask = sortedList [0];
                    sortedList.RemoveAt (0);
                    feedWorker (qTask);
                } else {
                    // Console.WriteLine ("waitingWorkers.Count=" + waitingWorkers.Count);
                    if (waitingWorkers.Count == numWorkers) {
                        finished = true;
                        stopWorkers ();
                    }
                    return;
                }
            }
        }

        public void add(QueueTask qTask) {
            lock (lockObj)
                sortedList.Add (qTask);
        }

        public void regWaiter(Worker worker) {
            lock (lockObj) {
                waitingWorkers.Add (worker);
                // Console.WriteLine ("reg: Waiting workers=" + waitingWorkers.Count);
                feedWorkers ();
            }
        }

        public void release(QueueTask qTask) {
            lock (lockObj) {
                // nothing to do in this case
            }
        }

        public void start() {
            if (sortedList.Count == 0 || finished) {
                Console.WriteLine ("Nothing to do.");
                finished = true;
                return;
            }
            for (int i = 0; i < numWorkers; i++) {
                Worker w = new Worker (this, i);
                workers.Add (w);
                w.Start ();
            }
            foreach (Worker w in workers) {
                w.Join ();
            }
            Console.WriteLine ("Finished!");
        }

        public void stop(int rc) {
            lock (lockObj) {
                this.rc = rc;
                finished = true;
            }
        }

    }

    class MainClass {
        public static void Main (string[] args) {
            Console.WriteLine ("Hello World!");
            Console.WriteLine("Number Of Logical Processors: {0}", Environment.ProcessorCount);
            BuildQueue queue = new BuildQueue (numWorkers: Environment.ProcessorCount);
            for (int i = 0; i < 5000; i++) {
                queue.add (new QueueTask ());
            }
            queue.start ();
        }
    }
}