Example_v4.cs.txt

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

namespace MultithreadingWorkloadsDistribution
{
    class Program
    {

        public static class_mulithreading_List mySharedList_multithreads = new class_mulithreading_List();
        public static class_mulithreading_Queue mySharedQueue_multithreads = new class_mulithreading_Queue();
        public static class_mulithreading_Stack mySharedStack_multithreads = new class_mulithreading_Stack();
        public static class_mulithreading_PriorityQueue mySharedPriority_multithreads = new class_mulithreading_PriorityQueue();
        private static System.Timers.Timer aTimer;
        private static int tmpCount = 10000;
        private static int[] myArray;
        private static Dictionary<int, int> myDict = new Dictionary<int, int>();

        static void Main(string[] args)
        {
            //Array memory allocation before any data Read / Write
            myArray = new int[20000];
            
            for (int i = 0; i < 20000; i++)
            {
                myArray[i] = 0;
            }
            

            //Hash Table memory allocation in advance before any data Read / Write
            for (int i = 0; i < 20000; i++)
            {
                myDict.Add(i, 0);
            }

            for (int i = 1; i <= 10000; i++)
            {
                //mySharedList_multithreads.Add(i);
                //mySharedQueue_multithreads.Enqueue(i);
                //mySharedStack_multithreads.Push(i);
                mySharedPriority_multithreads.Add(i, i);
            }

            int number_of_Program_Threads = Environment.ProcessorCount - 1;

            class_PrintNumber[] myMessagePrinter_class = new class_PrintNumber[number_of_Program_Threads];

            Thread[] threadsArray = new Thread[number_of_Program_Threads];

            for (int i = 0; i < number_of_Program_Threads; i++)
            {
                myMessagePrinter_class[i] = new class_PrintNumber(i + 1);
                threadsArray[i] = new Thread(new ThreadStart(myMessagePrinter_class[i].Print));
                threadsArray[i].Name = "WorkerID#" + i;
            }

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

            SetTimer();

            for (int i = 10001; i <= 20000; i++)
            {
                //mySharedList_multithreads.Add(i);
                //mySharedQueue_multithreads.Enqueue(i);
                //mySharedStack_multithreads.Push(i);
                mySharedPriority_multithreads.Add(i, i);
            }

            Console.WriteLine("\nFinished!");

            if (tmpCount >= 20000)
            {
                aTimer.Stop();
                aTimer.Dispose();
            }

            Console.Read();
        }

        private static void SetTimer()
        {
            // Create a timer and set a 0.001 second interval.
            aTimer = new System.Timers.Timer();
            aTimer.Interval = 1;

            // Hook up the Elapsed event for the timer. 
            aTimer.Elapsed += OnTimedEvent;

            // Have the timer fire repeated events (true is the default)
            aTimer.AutoReset = true;

            // Start the timer
            aTimer.Enabled = true;
        }

        private static void OnTimedEvent(Object source, ElapsedEventArgs e)
        {
            mySharedList_multithreads.Add(tmpCount++);
            //mySharedQueue_multithreads.Enqueue(tmpCount++);
            //mySharedStack_multithreads.Push(tmpCount++);
            //mySharedPriority_multithreads.Add(tmpCount++, tmpCount++);
            Random random = new Random();
            int tmpIndex = random.Next(0, 19999);
            Console.WriteLine("myArray[" + tmpIndex + "] = " + myArray[tmpIndex]);
            Console.WriteLine("myDict[" + tmpIndex + "] = " + myDict[tmpIndex]);
        }

        public class class_mulithreading_List
        {
            private List<int> List_multithreads;
            //private readonly object TaskQueueLock = new object();
            private static Random random;
            private int TagNumber, ListIndex;

            public class_mulithreading_List()
            {
                List_multithreads = new List<int>();
                random = new Random();
            }

            public void Add(int theTagNumber)
            {
                lock (List_multithreads)
                {
                    List_multithreads.Add(theTagNumber);
                }
            }

            public bool Any()
            {
                lock (List_multithreads)
                {
                    return List_multithreads.Any();
                }
            }

            public Tuple<bool, int> RandomRemove()
            {
                lock (List_multithreads)
                {
                    if (List_multithreads.Any())
                    {
                        ListIndex = random.Next(0, List_multithreads.Count() - 1);
                        TagNumber = List_multithreads.ElementAtOrDefault(ListIndex);
                        List_multithreads.RemoveAt(ListIndex);
                        //if no data from 'List_multithreads', return false. Else return true.
                        return new Tuple<bool, int>(true, TagNumber);
                    }
                    return new Tuple<bool, int>(false, -1);
                }
            }
        }

        public class class_mulithreading_Queue
        {
            private Queue<int> Queue_multithreads;
            //private readonly object TaskQueueLock = new object();

            public class_mulithreading_Queue()
            {
                Queue_multithreads = new Queue<int>();
            }

            public bool Any()
            {
                lock (Queue_multithreads)
                {
                    return Queue_multithreads.Any();
                }
            }

            public void Enqueue(int theTagNumber)
            {
                lock (Queue_multithreads)
                {
                    Queue_multithreads.Enqueue(theTagNumber);
                }
            }

            public Tuple<bool, int> Dequeue()
            {
                lock (Queue_multithreads)
                {
                    if (Queue_multithreads.Any())
                    {
                        //if no data from 'Queue_multithreads', return false. Else return true.
                        return new Tuple<bool, int>(true, Queue_multithreads.Dequeue());
                    }
                    return new Tuple<bool, int>(false, -1);
                }
            }
        }

        public class class_mulithreading_Stack
        {
            private Stack<int> Stack_multithreads;
            //private readonly object TaskQueueLock = new object();

            public class_mulithreading_Stack()
            {
                Stack_multithreads = new Stack<int>();
            }

            public bool Any()
            {
                lock (Stack_multithreads)
                {
                    return Stack_multithreads.Any();
                }
            }

            public void Push(int theTagNumber)
            {
                lock (Stack_multithreads)
                {
                    Stack_multithreads.Push(theTagNumber);
                }
            }

            public Tuple<bool, int> Pop()
            {
                lock (Stack_multithreads)
                {
                    if (Stack_multithreads.Any())
                    {
                        //if no data from 'Stack_multithreads', return false. Else return true.
                        return new Tuple<bool, int>(true, Stack_multithreads.Pop());
                    }
                    return new Tuple<bool, int>(false, -1);
                }
            }
        }

        public class class_mulithreading_PriorityQueue
        {
            //In 'PriorityQueue_multithreads', key is the Priority Level, value is the Tag Number.
            private SortedList<int, int> PriorityQueue_multithreads;
            private int TagNumber;
            //private readonly object TaskQueueLock = new object();

            public class_mulithreading_PriorityQueue()
            {
                PriorityQueue_multithreads = new SortedList<int, int>();
            }

            public bool Any()
            {
                lock (PriorityQueue_multithreads)
                {
                    return PriorityQueue_multithreads.Any();
                }
            }

            public void Add(int PriorityLevel, int theTagNumber)
            {
                lock (PriorityQueue_multithreads)
                {
                    PriorityQueue_multithreads.Add(PriorityLevel, theTagNumber);
                }
            }

            public Tuple<bool, int> Remove()
            {
                lock (PriorityQueue_multithreads)
                {
                    if (PriorityQueue_multithreads.Any())
                    {
                        TagNumber = PriorityQueue_multithreads.ElementAtOrDefault(0).Value;
                        //Alway remove the first node from PriorityQueue, presuming nodes at front have highest priority
                        PriorityQueue_multithreads.RemoveAt(0);

                        //if no data from 'Stack_multithreads', return false. Else return true.
                        return new Tuple<bool, int>(true, TagNumber);
                    }
                    return new Tuple<bool, int>(false, -1);
                }
            }
        }

        public class class_mulithreading_Dictionary
        {
            //In 'Dictionary_multithreads', key is the Tag Number, value is the computed result.
            private Dictionary<int, int> Dictionary_multithreads;
            private int Result;
            //private readonly object TaskQueueLock = new object();

            public class_mulithreading_Dictionary()
            {
                Dictionary_multithreads = new Dictionary<int, int>();
            }

            public bool Any()
            {
                lock(Dictionary_multithreads)
                {
                    return Dictionary_multithreads.Any();
                }
            }

            public void Add(int theTagNumber, int Result)
            {
                lock (Dictionary_multithreads)
                {
                    if (!Dictionary_multithreads.ContainsKey(theTagNumber))
                    {
                        Dictionary_multithreads.Add(theTagNumber, Result);
                    }
                }
            }

            public Tuple<bool, int> Remove(int theTagNumber)
            {
                lock (Dictionary_multithreads)
                {
                    if (Dictionary_multithreads.ContainsKey(theTagNumber))
                    {
                        Result = Dictionary_multithreads[theTagNumber];
                        Dictionary_multithreads.Remove(theTagNumber);
                        return new Tuple<bool, int>(true, Result);
                    }

                    return new Tuple<bool, int>(false, -1);
                }
            }

            public Tuple<bool, int> ElementAtKey(int theTagNumber)
            {
                lock (Dictionary_multithreads)
                {
                    if (Dictionary_multithreads.ContainsKey(theTagNumber))
                    {
                        Result = Dictionary_multithreads[theTagNumber];
                        return new Tuple<bool, int>(true, Result);
                    }

                    return new Tuple<bool, int>(false, -1);
                }
            }
        }

        class class_PrintNumber
        {
            private int threadID;

            public class_PrintNumber(int _threadID)
            {
                threadID = _threadID;
            }

            public void Print()
            {
                Tuple<bool, int> myNumber;

                //while (mySharedList_multithreads.Any())
                //while (mySharedQueue_multithreads.Any())
                //while (mySharedStack_multithreads.Any())
                while (mySharedPriority_multithreads.Any())
                {
                    //myNumber = mySharedList_multithreads.RandomRemove();
                    //myNumber = mySharedQueue_multithreads.Dequeue();
                    //myNumber = mySharedStack_multithreads.Pop();
                    myNumber = mySharedPriority_multithreads.Remove();
                    if (myNumber.Item1)
                    {
                        Random random = new Random();
                        myArray[myNumber.Item2] = random.Next(1, 10);
                        myDict[myNumber.Item2] = random.Next(1, 10);
                        Console.WriteLine("threadID: " + threadID + ", myArray[" + myNumber.Item2 + "] = " + myArray[myNumber.Item2]);
                        Console.WriteLine("threadID: " + threadID + ", myDict[" + myNumber.Item2 + "] = " + myDict[myNumber.Item2]);
                    }
                }
            }
        }
    }
}