PeriodicTask_ThreadPool_WaitState.cs.txt

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

namespace Queue_PeriodicTasks
{
    public class DuplicateKeyComparer<TKey>
                :
             IComparer<TKey> where TKey : IComparable
    {
        #region IComparer<TKey> Members

        public int Compare(TKey x, TKey y)
        {
            int result = x.CompareTo(y);

            if (result == 0)
                return 1;   // Handle equality as beeing greater
            else
                return result;
        }

        #endregion
    }

    class TimerQueue
    {
        public static bool RunProgram = true;
        public static class_currTimeDate currTimeDate = new class_currTimeDate();
        public static class_SortedList_PeriodicTasks SortedList_PeriodicTasks = new class_SortedList_PeriodicTasks();
        //public static class_PriorityQueue_PeriodicTasks PriorityQueue_PeriodicTasks = new class_PriorityQueue_PeriodicTasks();
        public static class_workerThread[] workerThread = new class_workerThread[2];
        public delegate void func_PeriodicTask();
        public static class_stack_workerThread_WaitState stack_workerThread_WaitState = new class_stack_workerThread_WaitState();

        static void Main(string[] args)
        {
            Thread[] WorkerThreadsArray = new Thread[2];
            for (int i = 0; i < 2; i++)
            {
                workerThread[i] = new class_workerThread(i);
                WorkerThreadsArray[i] = new Thread(new ThreadStart(workerThread[i].run_PeriodicTask));
                stack_workerThread_WaitState.Push(i);
            }

            SortedList_PeriodicTasks.add_PeriodicTask(DateTime.Now.AddSeconds(1), 1, 0, task_printTagNumber1);        //Periodic task function 'task_printTagNumber1', executed every 1 second. TagNumber = 0
            SortedList_PeriodicTasks.add_PeriodicTask(DateTime.Now.AddSeconds(2), 2, 1, task_printTagNumber2);        //Periodic task function 'task_printTagNumber2', executed every 2 second. TagNumber = 1
            SortedList_PeriodicTasks.add_PeriodicTask(DateTime.Now.AddSeconds(3), 3, 2, task_printTagNumber3);        //Periodic task function 'task_printTagNumber3', executed every 3 second. TagNumber = 2
            //PriorityQueue_PeriodicTasks.Add(DateTime.Now.AddSeconds(1), 1, 0, task_printTagNumber1);        //Periodic task function 'task_printTagNumber1', executed every 1 second. TagNumber = 0
            //PriorityQueue_PeriodicTasks.Add(DateTime.Now.AddSeconds(2), 2, 1, task_printTagNumber2);        //Periodic task function 'task_printTagNumber2', executed every 2 seconds. TagNumber = 1
            //PriorityQueue_PeriodicTasks.Add(DateTime.Now.AddSeconds(3), 3, 2, task_printTagNumber3);        //Periodic task function 'task_printTagNumber3', executed every 3 seconds. TagNumber = 2

            Thread Thread_TimerTick = new Thread(new ThreadStart(currTimeDate.TimerTick));
            Thread Thread_Queue_PeriodicTask = new Thread(new ThreadStart(SortedList_PeriodicTasks.run_PeriodicTask));
            //Thread Thread_Queue_PeriodicTask = new Thread(new ThreadStart(PriorityQueue_PeriodicTasks.run_PeriodicTask));

            Thread_Queue_PeriodicTask.Start();
            Thread_TimerTick.Start();
            foreach (Thread t in WorkerThreadsArray)
                t.Start();

            if (Convert.ToChar(Console.Read()) == 'q')              //Quit all subprocess threads and end the main program
            {
                RunProgram = false;
                workerThread[0].notify();
                workerThread[1].notify();
            }

            Thread_TimerTick.Join();
            Thread_Queue_PeriodicTask.Join();
            foreach (Thread t in WorkerThreadsArray)
                t.Join();
            // Join both threads with no timeout
            // Run both until done.
            // threads have finished at this point.

            Console.ReadKey();
        }

        struct struct_PeriodicTask
        {
            private DateTime next_trigger_DateTime;
            private int TaskPeriod_seconds;
            public int tagNumber;
            public func_PeriodicTask Execution_Function;

            public struct_PeriodicTask(DateTime _next_trigger_DateTime, int _TaskPeriod_seconds, int _tagNumber, func_PeriodicTask _Execution_Function)
            {
                TaskPeriod_seconds = _TaskPeriod_seconds;
                next_trigger_DateTime = _next_trigger_DateTime.AddSeconds(TaskPeriod_seconds);
                tagNumber = _tagNumber;
                Execution_Function = _Execution_Function;
            }
            
            public void set_next_trigger_DateTime(DateTime _next_trigger_DateTime)
            {
                next_trigger_DateTime = _next_trigger_DateTime;
            }
            
            public void set_next_trigger_DateTime()
            {
                next_trigger_DateTime = next_trigger_DateTime.AddSeconds(TaskPeriod_seconds);
            }

            public DateTime get_next_trigger_DateTime()
            {
                return next_trigger_DateTime;
            }
        };

        public class class_PriorityQueue_PeriodicTasks
        {
            private List<struct_PeriodicTask> PriorityQueue_PeriodicTasks;
            private bool isLocked;
            private bool PeriodicTimer_timed;

            public class_PriorityQueue_PeriodicTasks()
            {
                PriorityQueue_PeriodicTasks = new List<struct_PeriodicTask>();
                isLocked = false;
            }

            public bool Any()
            {
                bool _Any;

                Monitor.Enter(this);                        //obtain lock on this object

                //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                if (isLocked)
                    Monitor.Wait(this);                     //enter WaitSleepJoin state
                isLocked = true;

                try
                {
                    _Any = PriorityQueue_PeriodicTasks.Any();
                }
                finally
                {
                    isLocked = false;
                    Monitor.Pulse(this);                    //tell waiting thread(if there is one) to become ready to execute (Running state)
                    Monitor.Exit(this);                     //release lock on this object
                }

                return _Any;
            }

            public void Add(DateTime _next_trigger_DateTime, int _TaskPeriod_seconds, int _TagNumber, func_PeriodicTask _Execution_Function)
            {
                int insertPosition = 0;

                Monitor.Enter(this);                        //obtain lock on this object

                //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                if (isLocked)
                    Monitor.Wait(this);                     //enter WaitSleepJoin state
                isLocked = true;

                try
                {
                    if (_TaskPeriod_seconds <= 0)
                        Console.WriteLine("TaskPeriod_seconds cannot be equal or lesser than 0");

                    if (PriorityQueue_PeriodicTasks.Any())
                    {
                        foreach(struct_PeriodicTask PeriodicTask in PriorityQueue_PeriodicTasks)
                        {
                            if (_next_trigger_DateTime.CompareTo(PeriodicTask.get_next_trigger_DateTime()) > 0)
                                insertPosition++;
                            else
                                break;
                        }
                    }
                    PriorityQueue_PeriodicTasks.Insert(insertPosition, new struct_PeriodicTask(_next_trigger_DateTime, _TaskPeriod_seconds, _TagNumber, _Execution_Function));
                }
                finally
                {
                    isLocked = false;
                    Monitor.Pulse(this);                    //tell waiting thread(if there is one) to become ready to execute (Running state)
                    Monitor.Exit(this);                     //release lock on this object
                }
            }

            public void RemoveTagNumber(int _TagNumber)
            {
                int removePosition = 0;

                Monitor.Enter(this);                        //obtain lock on this object

                //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state
                isLocked = true;

                try
                {
                    if (PriorityQueue_PeriodicTasks.Any())
                    {
                        foreach (struct_PeriodicTask PeriodicTask in PriorityQueue_PeriodicTasks)
                        {
                            if (PeriodicTask.tagNumber != _TagNumber)
                                removePosition++;
                            else
                                break;
                        }
                        if (removePosition < PriorityQueue_PeriodicTasks.Count())
                            PriorityQueue_PeriodicTasks.RemoveAt(removePosition);
                    }
                }
                finally
                {
                    isLocked = false;
                    Monitor.Pulse(this);                //tell waiting thread(if there is one) to become ready to execute (Running state)
                    Monitor.Exit(this);                 //release lock on this object
                }
            }

            public void run_PeriodicTask()
            {
                Monitor.Enter(this);
                while (RunProgram)
                {
                    if (!PeriodicTimer_timed)
                        Monitor.Wait(this);

                    if (!PriorityQueue_PeriodicTasks.Any())
                        Monitor.Wait(this);

                    if (!stack_workerThread_WaitState.Any())
                        Monitor.Wait(this);

                    //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                    if (isLocked)
                        Monitor.Wait(this);                 //enter WaitSleepJoin state
                    isLocked = true;

                    try
                    {
                        if (PeriodicTimer_timed)
                        {
                            while (PriorityQueue_PeriodicTasks.Any() && currTimeDate.get_curr_DateTime().CompareTo(PriorityQueue_PeriodicTasks.First().get_next_trigger_DateTime()) >= 0 &&
                                stack_workerThread_WaitState.Any())
                            {
                                struct_PeriodicTask _struct_PeriodicTask = PriorityQueue_PeriodicTasks.First();
                                PriorityQueue_PeriodicTasks.RemoveAt(0);
                                workerThread[stack_workerThread_WaitState.Pop()].notify(_struct_PeriodicTask.Execution_Function);
                                _struct_PeriodicTask.set_next_trigger_DateTime();
                                int insertPosition = 0;
                                foreach (struct_PeriodicTask _Periodic_Task in PriorityQueue_PeriodicTasks)
                                {
                                    if (_struct_PeriodicTask.get_next_trigger_DateTime().CompareTo(_Periodic_Task.get_next_trigger_DateTime()) > 0)
                                        insertPosition++;
                                    else
                                        break;
                                }
                                PriorityQueue_PeriodicTasks.Insert(insertPosition, _struct_PeriodicTask);
                            }

                            if (PriorityQueue_PeriodicTasks.Any() && currTimeDate.get_curr_DateTime().CompareTo(PriorityQueue_PeriodicTasks.FirstOrDefault().get_next_trigger_DateTime()) < 0)
                                PeriodicTimer_timed = false;
                        }
                    }
                    finally
                    {
                        isLocked = false;
                        Monitor.Pulse(this);                    //tell waiting thread(if there is one) to become ready to execute (Running state)
                    }
                }
                Monitor.Exit(this);                     //release lock on this object
            }

            public void notify_timed()
            {
                Monitor.Enter(this);            //obtain lock on this object
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state
                isLocked = true;

                PeriodicTimer_timed = true;

                isLocked = false;
                Monitor.Pulse(this);            //tell waiting thread(if there is one) to become ready to execute (Running state)
                Monitor.Exit(this);             //release lock on this object
            }

            public void notify()
            {
                Monitor.Enter(this);            //obtain lock on this object
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state

                isLocked = false;
                Monitor.Pulse(this);            //tell waiting thread(if there is one) to become ready to execute (Running state)
                Monitor.Exit(this);             //release lock on this object
            }
        }

        public class class_currTimeDate
        {
            //This class "class_currTimeDate" is for simulation purpose only
            //Assuming class_currTimeDate is an accurate system clock, TimerTick() is hardware time ticking
            private DateTime curr_DateTime;
            private bool isLocked;

            public class_currTimeDate()
            {
                curr_DateTime = DateTime.Now;
                isLocked = false;
            }

            public void TimerTick()
            {
                while (RunProgram)
                {
                    Thread.Sleep(1000);
                    
                    Monitor.Enter(this);            //obtain lock on this object
                    if (isLocked)
                        Monitor.Wait(this);                 //enter WaitSleepJoin state
                    isLocked = true;

                    curr_DateTime = curr_DateTime.AddSeconds(1);
                    Console.WriteLine("Timer tick... " + curr_DateTime.ToString());

                    isLocked = false;
                    Monitor.Pulse(this);            //tell waiting thread(if there is one) to become ready to execute (Running state)
                    Monitor.Exit(this);             //release lock on this object

                    SortedList_PeriodicTasks.notify_timed();
                    //PriorityQueue_PeriodicTasks.notify_timed();
                }
            }

            public DateTime get_curr_DateTime()
            {
                DateTime _curr_DateTime;

                Monitor.Enter(this);            //obtain lock on this object
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state
                isLocked = true;

                _curr_DateTime = curr_DateTime;

                isLocked = false;
                Monitor.Pulse(this);            //tell waiting thread(if there is one) to become ready to execute (Running state)
                Monitor.Exit(this);             //release lock on this object

                return _curr_DateTime;
            }
        }

        public class class_SortedList_PeriodicTasks
        {
            private SortedList<DateTime, struct_PeriodicTask> SortedList_PeriodicTaskes;
            private bool isLocked;
            private bool PeriodicTimer_timed;

            public class_SortedList_PeriodicTasks()
            {
                SortedList_PeriodicTaskes = new SortedList<DateTime, struct_PeriodicTask>(new DuplicateKeyComparer<DateTime>());
                isLocked = false;
                PeriodicTimer_timed = false;
            }


            public void run_PeriodicTask()
            {
                Monitor.Enter(this);
                while (RunProgram)
                {
                    if (!PeriodicTimer_timed)
                        Monitor.Wait(this);

                    if (!SortedList_PeriodicTaskes.Any())
                        Monitor.Wait(this);

                    if(!stack_workerThread_WaitState.Any())
                        Monitor.Wait(this);

                    //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                    if (isLocked)
                        Monitor.Wait(this);                 //enter WaitSleepJoin state
                    isLocked = true;

                    try
                    {
                        if (PeriodicTimer_timed)
                        {
                            while (SortedList_PeriodicTaskes.Any() && currTimeDate.get_curr_DateTime().CompareTo(SortedList_PeriodicTaskes.FirstOrDefault().Key) >= 0 &&
                                stack_workerThread_WaitState.Any())
                            {
                                struct_PeriodicTask _struct_PeriodicTask = SortedList_PeriodicTaskes.ElementAtOrDefault(0).Value;
                                SortedList_PeriodicTaskes.RemoveAt(0);
                                workerThread[stack_workerThread_WaitState.Pop()].notify(_struct_PeriodicTask.Execution_Function);
                                _struct_PeriodicTask.set_next_trigger_DateTime();
                                SortedList_PeriodicTaskes.Add(_struct_PeriodicTask.get_next_trigger_DateTime(), _struct_PeriodicTask);
                            }
                            
                            if(SortedList_PeriodicTaskes.Any() && currTimeDate.get_curr_DateTime().CompareTo(SortedList_PeriodicTaskes.FirstOrDefault().Key) < 0)
                                PeriodicTimer_timed = false;
                        }
                    }
                    finally
                    {
                        isLocked = false;
                        Monitor.Pulse(this);                    //tell waiting thread(if there is one) to become ready to execute (Running state)
                    }
                }
                Monitor.Exit(this);                     //release lock on this object
            }

            public void add_PeriodicTask(DateTime _next_trigger_DateTime, int TaskPeriod_seconds, int tagNumber, func_PeriodicTask Execution_Function)
            {
                Monitor.Enter(this);
                //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state
                isLocked = true;

                SortedList_PeriodicTaskes.Add(_next_trigger_DateTime, new struct_PeriodicTask(_next_trigger_DateTime, TaskPeriod_seconds, tagNumber, Execution_Function));

                isLocked = false;
                Monitor.Pulse(this);                    //tell waiting thread(if there is one) to become ready to execute (Running state)
                Monitor.Exit(this);
            }

            public void notify_timed()
            {
                Monitor.Enter(this);                    //obtain lock on this object
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state
                isLocked = true;

                PeriodicTimer_timed = true;

                isLocked = false;
                Monitor.Pulse(this);                    //tell waiting thread(if there is one) to become ready to execute (Running state)
                Monitor.Exit(this);                     //release lock on this object
            }

            public void notify()
            {
                Monitor.Enter(this);                    //obtain lock on this object
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state

                isLocked = false;
                Monitor.Pulse(this);            //tell waiting thread(if there is one) to become ready to execute (Running state)
                Monitor.Exit(this);             //release lock on this object
            }
        }

        public class class_stack_workerThread_WaitState
        {
            private Stack<int> queue_workerThread_WaitState;
            private bool isLocked;

            public class_stack_workerThread_WaitState()
            {
                queue_workerThread_WaitState = new Stack<int>();
                isLocked = false;
            }

            public bool Any()
            {
                bool _Any;

                Monitor.Enter(this);                        //obtain lock on this object

                //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                if (isLocked)
                    Monitor.Wait(this);                     //enter WaitSleepJoin state
                isLocked = true;

                try
                {
                    _Any = queue_workerThread_WaitState.Any();
                }
                finally
                {
                    isLocked = false;
                    Monitor.Pulse(this);                    //tell waiting thread(if there is one) to become ready to execute (Running state)
                    Monitor.Exit(this);                     //release lock on this object
                }

                return _Any;
            }

            public void Push(int WorkerThread_ReadyState_TagNumber)
            {
                Monitor.Enter(this);                        //obtain lock on this object

                //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                if (isLocked)
                    Monitor.Wait(this);                     //enter WaitSleepJoin state
                isLocked = true;

                try
                {
                    queue_workerThread_WaitState.Push(WorkerThread_ReadyState_TagNumber);
                }
                finally
                {
                    isLocked = false;
                    Monitor.Pulse(this);                    //tell waiting thread(if there is one) to become ready to execute (Running state)
                    Monitor.Exit(this);                     //release lock on this object
                }
            }

            public int Pop()
            {
                int TagNumber = 0;

                Monitor.Enter(this);                        //obtain lock on this object

                if (!queue_workerThread_WaitState.Any())
                    Monitor.Wait(this);

                //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state
                isLocked = true;

                try
                {
                    if (queue_workerThread_WaitState.Any())
                    {
                        TagNumber = queue_workerThread_WaitState.Pop();
                    }
                }
                finally
                {
                    isLocked = false;
                    if (queue_workerThread_WaitState.Any())
                        Monitor.Pulse(this);            //tell waiting thread(if there is one) to become ready to execute (Running state)
                }

                Monitor.Exit(this);                         //release lock on this object

                return TagNumber;
            }
        }

        public class class_workerThread
        {
            //This class "class_workerThread" is written for simulation purpose only
            //Actual task program will stil need to have 'entering wait stage' coding, 'be notified' coding
            private bool isLocked;
            public int WorkerThread_ID;
            private bool PeriodicTimer_timed;
            private func_PeriodicTask _PeriodicTask;

            public class_workerThread(int _WorkerThread_ID)
            {
                isLocked = false;
                WorkerThread_ID = _WorkerThread_ID;
                PeriodicTimer_timed = false;
            }

            public void run_PeriodicTask()
            {
                Monitor.Enter(this);
                while (RunProgram)
                {
                    if(!PeriodicTimer_timed)
                        Monitor.Wait(this);                 //enter WaitSleepJoin state

                    //if other thread is at present reading / editing this object (isLocked == true), place invoking thread in WaitSleepJoin state
                    if (isLocked)
                        Monitor.Wait(this);                 //enter WaitSleepJoin state
                    isLocked = true;

                    Console.Write("Thread " + WorkerThread_ID + " run: ");
                    if (RunProgram)
                        _PeriodicTask();
                        
                    PeriodicTimer_timed = false;
                    stack_workerThread_WaitState.Push(WorkerThread_ID);
                    SortedList_PeriodicTasks.notify();
                    //PriorityQueue_PeriodicTasks.notify();

                    isLocked = false;
                    Monitor.Pulse(this);            //tell waiting thread(if there is one) to become ready to execute (Running state)
                }
                Monitor.Exit(this);             //release lock on this object
            }

            public void notify(func_PeriodicTask _func_PeriodicTask)
            {
                Monitor.Enter(this);            //obtain lock on this object
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state
                isLocked = true;

                _PeriodicTask = _func_PeriodicTask;
                PeriodicTimer_timed = true;

                isLocked = false;
                Monitor.Pulse(this);            //tell waiting thread(if there is one) to become ready to execute (Running state)
                Monitor.Exit(this);             //release lock on this object
            }

            public void notify()
            {
                Monitor.Enter(this);            //obtain lock on this object
                if (isLocked)
                    Monitor.Wait(this);                 //enter WaitSleepJoin state

                isLocked = false;
                Monitor.Pulse(this);            //tell waiting thread(if there is one) to become ready to execute (Running state)
                Monitor.Exit(this);             //release lock on this object
            }
        }

        private static void task_printTagNumber1()
        {
            //for demo purpose
            //Periodic task function #1 that will be executed by Task Threads
            Console.WriteLine("Running Periodic Task #1");
        }

        private static void task_printTagNumber2()
        {
            //for demo purpose
            //Periodic task function #2 that will be executed by Task Threads
            Console.WriteLine("Running Periodic Task #2");
        }

        private static void task_printTagNumber3()
        {
            //for demo purpose
            //Periodic task function #3 that will be executed by Task Threads
            Console.WriteLine("Running Periodic Task #3");
        }
    }
}