Лабораторная 3 по ААС

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

namespace Lab_3_AAC
{
    class Program
    {
        static int[] MessagesCountList = { 100, 500, 1000 };
        static int[] MessagesSizeList = { 50, 100, 200 };
        static int[] ThreadCountList = { 6, 12, 24 };
        static string Buffer;
        //M общие
        static int ProcessIndex;
        static bool bEmpty;
        static bool finish;
        //M3
        static AutoResetEvent[] state = new AutoResetEvent[2];
        static List<string> result = new List<string>();
        //M4
        static SemaphoreSlim semaphore;
        static void Main(string[] args)
        {
            int ParamAmounts = MessagesCountList.Length * MessagesSizeList.Length * ThreadCountList.Length;
            string avgText = "Среднее время первого метода: " + FirstMethod()/ParamAmounts + "\n" +
                "Среднее время второго метода: " + SecondMethod()/ParamAmounts + "\n" +
                "Среднее время третьего метода: " + ThirdMethod()/ParamAmounts + "\n" +
                "Среднее время четвертого метода: " + FourthMethod()/ParamAmounts + "\n" +
                "Среднее время пятого метода: " + FivesMethod()/ParamAmounts + "\n";
            Console.WriteLine(avgText);
            Console.ReadLine();
        }
        static string[] SetMessages(int indexMesCount, int indexMesSize)
        {
            string[] result = new string[MessagesCountList[indexMesCount]];
            Random rand = new Random();
            for (int i = 0; i < MessagesCountList[indexMesCount]; i++)
            {
                result[i] = RepeatTheChar("ABCDE"[rand.Next(4)], MessagesSizeList[indexMesSize]);
            }
            return result;
        }
        static string RepeatTheChar(char c, int count)
        {
            string result = "";
            for (int i = 0; i < count; i++)
            {
                result += c;
            }
            return result;
        }
        static float FirstMethod()
        {
            float allTime = 0f;
            for (int ThreadCountIndex = 0; ThreadCountIndex < ThreadCountList.Length; ThreadCountIndex++)
            {
                for (int MessageCountIndex = 0; MessageCountIndex < MessagesCountList.Length; MessageCountIndex++)
                {
                    for (int MessageSizeIndex = 0; MessageSizeIndex < MessagesSizeList.Length; MessageSizeIndex++)
                    {
                        string[] Messages = SetMessages(MessageCountIndex, MessageSizeIndex);
                        ProcessIndex = 0;
                        result.Clear();
                        bEmpty = true;
                        finish = false;
                        Stopwatch time = new Stopwatch();
                        time.Start();
                        Thread[] writers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        Thread[] readers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i] = new Thread(WriterM1);
                            writers[i].Start(Messages);
                        }
                        for (int i = 0; i < readers.Length; i++)
                        {
                            readers[i] = new Thread(ReaderM1);
                            readers[i].Start();
                        }
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i].Join();
                        }
                        finish = true;
                        for (int i = 0; i < readers.Length; i++)
                        {
                            readers[i].Join();
                        }
                        time.Stop();
                        Console.WriteLine("Время при коллич потоков: {0}, коллич сообщений: {1}, размере сообщений {2}: {3} ms",
                            ThreadCountList[ThreadCountIndex], MessagesCountList[MessageCountIndex], MessagesSizeList[MessageSizeIndex], time.ElapsedMilliseconds);
                        allTime += time.ElapsedMilliseconds;
                    }
                }
            }
            return allTime;
        }
        static float SecondMethod()
        {
            float allTime = 0f;
            for (int ThreadCountIndex = 0; ThreadCountIndex < ThreadCountList.Length; ThreadCountIndex++)
            {
                for (int MessageCountIndex = 0; MessageCountIndex < MessagesCountList.Length; MessageCountIndex++)
                {
                    for (int MessageSizeIndex = 0; MessageSizeIndex < MessagesSizeList.Length; MessageSizeIndex++)
                    {
                        string[] Messages = SetMessages(MessageCountIndex, MessageSizeIndex);
                        ProcessIndex = 0;
                        result.Clear();
                        bEmpty = true;
                        finish = false;
                        Stopwatch time = new Stopwatch();
                        time.Start();
                        Thread[] writers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        Thread[] readers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i] = new Thread(WriterM2);
                            writers[i].Start(Messages);
                        }
                        for (int i = 0; i < readers.Length; i++)
                        {
                            readers[i] = new Thread(ReaderM2);
                            readers[i].Start();
                        }
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i].Join();
                        }
                        finish = true;
                        for (int i = 0; i < readers.Length; i++)
                        {
                            readers[i].Join();
                        }
                        time.Stop();
                        Console.WriteLine("Время при коллич потоков: {0}, коллич сообщений: {1}, размере сообщений {2}: {3} ms",
                            ThreadCountList[ThreadCountIndex], MessagesCountList[MessageCountIndex], MessagesSizeList[MessageSizeIndex], time.ElapsedMilliseconds);
                        allTime += time.ElapsedMilliseconds;
                    }
                }
            }
            return allTime;
        }
        static float ThirdMethod()
        {
            float allTime = 0f;
            for (int ThreadCountIndex = 0; ThreadCountIndex < ThreadCountList.Length; ThreadCountIndex++)
            {
                for (int MessageCountIndex = 0; MessageCountIndex < MessagesCountList.Length; MessageCountIndex++)
                {
                    for (int MessageSizeIndex = 0; MessageSizeIndex < MessagesSizeList.Length; MessageSizeIndex++)
                    {
                        string[] Messages = SetMessages(MessageCountIndex, MessageSizeIndex);
                        ProcessIndex = 0;
                        result.Clear();
                        finish = false;
                        state[0] = new AutoResetEvent(false);
                        state[1] = new AutoResetEvent(true);
                        Stopwatch time = new Stopwatch();
                        time.Start();
                        Thread[] writers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        Thread[] readers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i] = new Thread(WriterM3);
                            writers[i].Start(Messages);
                        }
                        for (int i = 0; i < readers.Length; i++)
                        {
                            readers[i] = new Thread(ReaderM3);
                            readers[i].Start();
                        }
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i].Join();
                        }
                        finish = true;
                        for (int i = 0; i < readers.Length; i++)
                        {
                            while (readers[i].IsAlive)
                            {
                                state[0].Set();
                            }
                            readers[i].Join();
                        }
                        time.Stop();
                        Console.WriteLine("Время при коллич потоков: {0}, коллич сообщений: {1}, размере сообщений {2}: {3} ms",
                            ThreadCountList[ThreadCountIndex], MessagesCountList[MessageCountIndex], MessagesSizeList[MessageSizeIndex], time.ElapsedMilliseconds);
                        allTime += time.ElapsedMilliseconds;
                    }
                }
            }
            return allTime;
        }
        static float FourthMethod()
        {
            float allTime = 0f;
            for (int ThreadCountIndex = 0; ThreadCountIndex < ThreadCountList.Length; ThreadCountIndex++)
            {
                for (int MessageCountIndex = 0; MessageCountIndex < MessagesCountList.Length; MessageCountIndex++)
                {
                    for (int MessageSizeIndex = 0; MessageSizeIndex < MessagesSizeList.Length; MessageSizeIndex++)
                    {
                        string[] Messages = SetMessages(MessageCountIndex, MessageSizeIndex);
                        ProcessIndex = 0;
                        result.Clear();
                        bEmpty = true;
                        finish = false;
                        semaphore = new SemaphoreSlim(ThreadCountList[ThreadCountIndex], ThreadCountList[ThreadCountIndex]);
                        Stopwatch time = new Stopwatch();
                        time.Start();
                        Thread[] writers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        Thread[] readers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i] = new Thread(WriterM4);
                            writers[i].Start(Messages);
                        }
                        for (int i = 0; i < readers.Length; i++)
                        {
                            readers[i] = new Thread(ReaderM4);
                            readers[i].Start();
                        }
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i].Join();
                        }
                        finish = true;
                        for (int i = 0; i < readers.Length; i++)
                        {
                            readers[i].Join();
                        }
                        time.Stop();
                        Console.WriteLine("Время при коллич потоков: {0}, коллич сообщений: {1}, размере сообщений {2}: {3} ms",
                            ThreadCountList[ThreadCountIndex], MessagesCountList[MessageCountIndex], MessagesSizeList[MessageSizeIndex], time.ElapsedMilliseconds);
                        allTime += time.ElapsedMilliseconds;
                    }
                }
            }
            return allTime;
        }
        static float FivesMethod()
        {
            float allTime = 0f;
            for (int ThreadCountIndex = 0; ThreadCountIndex < ThreadCountList.Length; ThreadCountIndex++)
            {
                for (int MessageCountIndex = 0; MessageCountIndex < MessagesCountList.Length; MessageCountIndex++)
                {
                    for (int MessageSizeIndex = 0; MessageSizeIndex < MessagesSizeList.Length; MessageSizeIndex++)
                    {
                        string[] Messages = SetMessages(MessageCountIndex, MessageSizeIndex);
                        ProcessIndex = 0;
                        result.Clear();
                        bEmpty = true;
                        finish = false;
                        Stopwatch time = new Stopwatch();
                        time.Start();
                        Thread[] writers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        Thread[] readers = new Thread[ThreadCountList[ThreadCountIndex] / 2];
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i] = new Thread(WriterM5);
                            writers[i].Start(Messages);
                        }
                        for (int i = 0; i < readers.Length; i++)
                        {
                            readers[i] = new Thread(ReaderM5);
                            readers[i].Start();
                        }
                        for (int i = 0; i < writers.Length; i++)
                        {
                            writers[i].Join();
                        }
                        finish = true;
                        for (int i = 0; i < readers.Length; i++)
                        {
                            readers[i].Join();
                        }
                        time.Stop();
                        Console.WriteLine("Время при коллич потоков: {0}, коллич сообщений: {1}, размере сообщений {2}: {3} ms",
                            ThreadCountList[ThreadCountIndex], MessagesCountList[MessageCountIndex], MessagesSizeList[MessageSizeIndex], time.ElapsedMilliseconds);
                        allTime += time.ElapsedMilliseconds;
                    }
                }
            }
            return allTime;
        }
        static void WriterM1(Object o)
        {
            while (ProcessIndex < ((string[])o).Length)
            {
                if (bEmpty)
                {
                    try
                    { Buffer = ((string[])o)[ProcessIndex++]; }
                    catch { break; }
                    bEmpty = false;
                }
            }
        }
        static void ReaderM1()
        {
            while (!finish)
            {
                if (!bEmpty)
                {
                    result.Add(Buffer);
                    bEmpty = true;
                }
            }
        }
        static void WriterM2(Object o)
        {
            while (ProcessIndex < ((string[])o).Length)
            {
                lock ("write")
                {
                    if (bEmpty)
                    {
                        try
                        { Buffer = ((string[])o)[ProcessIndex++]; }
                        catch { break; }
                        bEmpty = false;
                    }
                }
            }
        }
        static void ReaderM2()
        {
            while (!finish)
            {
                if (!bEmpty)
                {
                    lock ("read")
                    {
                        if (!bEmpty)
                        {
                            result.Add(Buffer);
                            bEmpty = true;
                        }
                    }
                }
            }
        }
        static void ReaderM3()
        {
            var evFull = state[0] as AutoResetEvent;
            var evEmpty = state[1] as AutoResetEvent;
            while (true)
            {
                evFull.WaitOne();
                if (finish) break;
                // Сигнал о завершении работы
                result.Add(Buffer);
                evEmpty.Set();
            }
        }
        static void WriterM3(object o)
        {
            var evFull = state[0] as AutoResetEvent;
            var evEmpty = state[1] as AutoResetEvent;
            while (ProcessIndex < ((string[])o).Length)
            {
                evEmpty.WaitOne();
                try { Buffer = ((string[])o)[ProcessIndex++]; }
                catch { evFull.Set(); break; }
                evFull.Set();
            }
        }
        static void ReaderM4()
        {
            var semReader = semaphore as SemaphoreSlim;
            while (!finish)
            {
                if (!bEmpty)
                {
                    semReader.Wait();
                    if (!bEmpty)
                    {
                        bEmpty = true;
                        result.Add(Buffer);
                    }
                    semReader.Release();
                }
            }
        }
        static void WriterM4(object o)
        {
            var semWriter = semaphore as SemaphoreSlim;
            while (ProcessIndex < ((string[])o).Length)
            {
                if (bEmpty)
                {
                    semWriter.Wait();
                    if (bEmpty)
                    {
                        bEmpty = false;
                        try{ Buffer = ((string[])o)[ProcessIndex++]; }
                        catch { break; }
                    }
                    semWriter.Release();
                }
            }
        }
        static void WriterM5(Object o)
        {
            while (ProcessIndex < ((string[])o).Length)
            {
                if (bEmpty)
                {
                    try{ Buffer = ((string[])o)[Interlocked.Increment(ref ProcessIndex)]; }
                    catch { break; }
                    bEmpty = false;
                }
            }
        }
        static void ReaderM5()
        {
            while (!finish)
            {
                if (!bEmpty)
                {
                    lock ("read")
                    {
                        if (!bEmpty)
                        {
                            result.Add(Buffer);
                            bEmpty = true;
                        }
                    }
                }
            }
        }
    }
}