fork download
copy 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  7.  
  8. namespace CourseWork_code
  9. {
  10.     #region Ініціалізація головних змінних в проекті
  11.     class Shared
  12.     {
  13.         public static int N = 8;
  14.         public static int H = N / 4;
  15.         public static int[] A = new int[N];
  16.         public static int[] B = new int[N];
  17.         public static int[] Z = new int[N];
  18.         public static int[,] MC = new int[N, N];
  19.         public static int[,] MD = new int[N, N];
  20.         public static int[,] CalcMO = new int[N, N];
  21.         public static int[] CalcMP = new int[N];
  22.  
  23.         public static Semaphore T1Data = new Semaphore(4, 10);
  24.         public static Semaphore T2Data = new Semaphore(4, 10);
  25.         public static Semaphore T3Data = new Semaphore(4, 10);
  26.         public static Semaphore T4Data = new Semaphore(4, 10);
  27.  
  28.         public static Semaphore T1Copy = new Semaphore(4, 10);
  29.         public static Semaphore T2Copy = new Semaphore(4, 10);
  30.         public static Semaphore T3Copy = new Semaphore(4, 10);
  31.         public static Semaphore T4Copy = new Semaphore(4, 10);
  32.  
  33.         public static Semaphore T1Release = new Semaphore(4, 10);
  34.         public static Semaphore T2Release = new Semaphore(4, 10);
  35.         public static Semaphore T3Release = new Semaphore(4, 10);
  36.         public static Semaphore T4Release = new Semaphore(4, 10);
  37.  
  38.         public static Semaphore T1OutputData = new Semaphore(10, 10);
  39.     }
  40.     #endregion
  41.  
  42.     class T1
  43.     {
  44.         public Thread thread_1;
  45.         public T1(string name)
  46.         {
  47.             thread_1 = new Thread(new ThreadStart(this.Run));
  48.             thread_1.Name = name;
  49.             thread_1.Start();
  50.         }
  51.         void Run()
  52.         {
  53.             Console.WriteLine("\nFirst thread started!");
  54.             Console.WriteLine($"{thread_1.Name} начинает вводить данные");
  55.             //Shared.Data.WaitOne();
  56.  
  57.             /*#region Ініціалізація даних
  58.             for (int i = 0; i < Shared.N; i++)
  59.             {
  60.                 Shared.A[i] = 0;
  61.                 Shared.Z[i] = 1;
  62.             }
  63.             #endregion*/
  64.  
  65.             Console.WriteLine($"{thread_1.Name} заканчивает ввод данных данных");
  66.             Console.WriteLine($"{thread_1.Name} отдаёт сигнал про завершения ввода другим потокам");
  67.             Shared.T1Data.Release();
  68.  
  69.             Console.WriteLine($"{thread_1.Name} ждёт сигнал про завершения ввода от второго потока");
  70.             Shared.T2Data.WaitOne();
  71.             Console.WriteLine($"{thread_1.Name} получил сигнал про завершения ввода от второго потока");
  72.             Console.WriteLine($"{thread_1.Name} ждёт сигнал про завершения ввода от четвёртого потока");
  73.             Shared.T4Data.WaitOne();
  74.             Console.WriteLine($"{thread_1.Name} получил сигнал про завершения ввода от четвёртого потока");
  75.  
  76.             Console.WriteLine($"{thread_1.Name} начинает копировать данные");
  77.  
  78.             /*#region Копіювання даних
  79.             int[] B1 = new int[Shared.H/2];
  80.             for (int i = 0; i < Shared.H/2; i++)
  81.             {
  82.                 B1[i] = Shared.B[i];
  83.             }
  84.             int[,] MC1 = new int[Shared.H/2, Shared.N];
  85.             for (int i = 0; i < Shared.H/2; i++)
  86.             {
  87.                 for (int j = 0; j < Shared.N; j++)
  88.                 {
  89.                     MC1[i, j] = Shared.MC[i, j];
  90.                 }
  91.             }
  92.             #endregion*/
  93.             Console.WriteLine($"{thread_1.Name} заканчивает копировать данные и отдаёт сигнал про завершение копирования другим потокам");
  94.             Shared.T1Copy.Release();
  95.             Shared.T1Copy.WaitOne();
  96.             Console.WriteLine($"{thread_1.Name} принял сигнал про завершение копирования от первого потока");
  97.  
  98.             Console.Write($"{thread_1.Name} осуществляет расчёты задачи");
  99.  
  100.             /*#region Обчислення задачі
  101.             int[,] CalcMO1 = new int[Shared.H/2, Shared.N];
  102.             for (int t = 0; t < Shared.H/2; t++)
  103.             {
  104.                 for (int i = 0; i < Shared.H/2; i++)
  105.                 {
  106.                     for (int j = 0; j < Shared.N; j++)
  107.                     {
  108.                         CalcMO1[i, j] += MC1[i, t] * Shared.MD[i, j];
  109.                     }
  110.                 }
  111.             }
  112.  
  113.             int[] CalcMP1 = new int[Shared.N];
  114.             for (int i = 0; i < Shared.H/2; i++)
  115.             {
  116.                 for (int j = 0; j < Shared.N; j++)
  117.                 {
  118.                     CalcMP1[i] += B1[i] * CalcMO1[i, j];
  119.                 }
  120.             }
  121.  
  122.             for (int i = 0; i < Shared.H/2; i++)
  123.             {
  124.                 Shared.A[i] = CalcMP1[i] + Shared.Z[i];
  125.             }
  126.             #endregion*/
  127.  
  128.             Console.WriteLine($"{thread_1.Name} закончил считать и отдаёт об этом сигнал другим потокам");
  129.             Shared.T1Release.Release();
  130.             //Shared.T1OutputData.WaitOne();
  131.  
  132.             /*#region Вивід даних
  133.             Console.Write("A = ");
  134.             for (int i = 0; i < Shared.N; i++)
  135.             {
  136.                 Console.Write($"{Shared.A[i]} ");
  137.             }
  138.             #endregion*/
  139.  
  140.             //Shared.T1OutputData.Release();
  141.  
  142.             Console.WriteLine("\nFirst thread finished!");
  143.         }
  144.     }
  145.     class T2
  146.     {
  147.         public Thread thread_2;
  148.         public T2(string name)
  149.         {
  150.             thread_2 = new Thread(new ThreadStart(this.Run));
  151.             thread_2.Name = name;
  152.             thread_2.Start();
  153.         }
  154.         void Run()
  155.         {
  156.             Console.Write("\nSecond thread started!");
  157.  
  158.             //Shared.Data.WaitOne();
  159.             //Shared.Copy.WaitOne();
  160.  
  161.             /*#region Ініціалізація даних
  162.             for (int i = 0; i < Shared.N; i++)
  163.             {
  164.                 Shared.B[i] = 1;
  165.             }
  166.  
  167.             for (int i = 0; i < Shared.N; i++)
  168.             {
  169.                 for (int j = 0; j < Shared.N; j++)
  170.                 {
  171.                     Shared.MD[i, j] = 1;
  172.                 }
  173.             }
  174.             #endregion*/
  175.  
  176.             Console.WriteLine($"{thread_2.Name} начинает вводить данные");
  177.             Console.WriteLine($"{thread_2.Name} заканчивает ввод данных данных");
  178.             Console.WriteLine($"{thread_2.Name} отдаёт сигнал про завершения ввода другим потокам");
  179.             Shared.T2Data.Release();
  180.  
  181.             //Shared.T2Copy.WaitOne();
  182.  
  183.             /*#region Копіювання даних
  184.             int[] B2 = new int[Shared.H];
  185.             for (int i = Shared.H/2; i < Shared.H*2; i++)
  186.             {
  187.                 B2[i] = Shared.B[i];
  188.             }*/
  189.             Console.WriteLine($"{thread_2.Name} ждёт сигнал про завершения ввода от четвёртого потока");
  190.             Shared.T4Data.WaitOne();
  191.             Console.WriteLine($"{thread_2.Name} получил сигнал про завершения ввода от четвёртого потока");
  192.  
  193.             Console.WriteLine($"{thread_2.Name} начинает копировать данные");
  194.             /*int[,] MC2 = new int[Shared.H/2, Shared.N];
  195.             for (int i = Shared.H/2; i < Shared.H*2; i++)
  196.             {
  197.                 for (int j = 0; j < Shared.N; j++)
  198.                 {
  199.                     MC2[i, j] = Shared.MC[i, j];
  200.                 }
  201.             }
  202.             #endregion*/
  203.             Console.WriteLine($"{thread_2.Name} заканчивает копировать данные и отдаёт сигнал про завершение копирования другим потокам");
  204.             Shared.T2Copy.Release();
  205.             Console.WriteLine($"{thread_2.Name} ждёт сигнал про завершение копирования от второго потока");
  206.             Shared.T2Copy.WaitOne();
  207.             Console.WriteLine($"{thread_2.Name} принял сигнал про завершение копирования от второго потока");
  208.  
  209.             Console.Write($"{thread_2.Name} осуществляет расчёты задачи");
  210.  
  211.             /*#region Обчислення задачі
  212.             int[,] CalcMO2 = new int[Shared.H/2, Shared.N];
  213.             for (int t = Shared.H/2; t < Shared.H*2; t++)
  214.             {
  215.                 for (int i = Shared.H/2; i < Shared.H*2; i++)
  216.                 {
  217.                     for (int j = 0; j < Shared.N; j++)
  218.                     {
  219.                         CalcMO2[i, j] += MC2[i, t] * Shared.MD[t, j];
  220.                     }
  221.                 }
  222.             }
  223.  
  224.             int[] CalcMP2 = new int[Shared.H/2];
  225.             for (int i = Shared.H/2; i < Shared.H*2; i++)
  226.             {
  227.                 for (int j = 0; j < Shared.N; j++)
  228.                 {
  229.                     CalcMP2[i] += B2[i] * CalcMO2[i, j];
  230.                 }
  231.             }
  232.  
  233.             for (int i = Shared.H/2; i < Shared.H*2; i++)
  234.             {
  235.                 Shared.A[i] = CalcMP2[i] + Shared.Z[i];
  236.             }
  237.             #endregion*/
  238.             Console.WriteLine($"{thread_2.Name} закончил считать и отдаёт об этом сигнал другим потокам");
  239.             Shared.T2Release.Release();
  240.             Console.WriteLine("\nSecond thread finished!");
  241.  
  242.             /*Console.Write("A = ");
  243.             for (int i = Shared.H/2; i < Shared.H*2; i++)
  244.             {
  245.                 Console.Write($"{Shared.A[i]} ");
  246.             }*/
  247.         }
  248.     }
  249.  
  250.     class T3
  251.     {
  252.         public Thread thread_3;
  253.         public T3(string name)
  254.         {
  255.             thread_3 = new Thread(new ThreadStart(this.Run));
  256.             thread_3.Name = name;
  257.             thread_3.Start();
  258.         }
  259.         void Run()
  260.         {
  261.             Console.Write("\nThird thread started!");
  262.  
  263.             Console.WriteLine($"{thread_3.Name} ждёт сигнал про завершения ввода от второго потока");
  264.             Shared.T2Data.WaitOne();
  265.             Console.WriteLine($"{thread_3.Name} получил сигнал про завершения ввода от второго потока");
  266.             Console.WriteLine($"{thread_3.Name} ждёт сигнал про завершения ввода от четвёртого потока");
  267.             Shared.T4Data.WaitOne();
  268.             Console.WriteLine($"{thread_3.Name} получил сигнал про завершения ввода от четвёртого потока");
  269.  
  270.             /*#region Копіювання даних
  271.             int[] B3 = new int[Shared.H/2];
  272.             for (int i = Shared.H*2; i < Shared.H*3; i++)
  273.             {
  274.                 B3[i] = Shared.B[i];
  275.             }*/
  276.  
  277.             Console.WriteLine($"{thread_3.Name} начинает копировать данные");
  278.             Console.WriteLine($"{thread_3.Name} заканчивает копировать данные и отдаёт сигнал про завершение копирования другим потокам");
  279.             Shared.T3Copy.Release();
  280.             Console.WriteLine($"{thread_3.Name} ждёт сигнал про завершение копирования от третьего потока");
  281.             Shared.T3Copy.WaitOne();
  282.             Console.WriteLine($"{thread_3.Name} принял сигнал про завершение копирования от третьего потока");
  283.  
  284.             /*int[,] MC3 = new int[Shared.H/2, Shared.N];
  285.             for (int i = Shared.H*2; i < Shared.H*3; i++)
  286.             {
  287.                 for (int j = 0; j < Shared.N; j++)
  288.                 {
  289.                     MC3[i, j] = Shared.MC[i, j];
  290.                 }
  291.             }
  292.             #endregion*/
  293.  
  294.             Console.Write($"{thread_3.Name} осуществляет расчёты задачи");
  295.  
  296.             //Shared.T3Release.Release();
  297.             //Shared.T1Data.WaitOne();
  298.             //Shared.T4Data.WaitOne();
  299.  
  300.             /*#region Обчислення задачі
  301.             int[,] CalcMO3 = new int[Shared.H/2, Shared.N];
  302.             for (int t = Shared.H*2; t < Shared.H*3; t++)
  303.             {
  304.                 for (int i = Shared.H*2; i < Shared.H*3; i++)
  305.                 {
  306.                     for (int j = 0; j < Shared.N; j++)
  307.                     {
  308.                         CalcMO3[i, j] += MC3[i, t] * Shared.MD[t, j];
  309.                     }
  310.                 }
  311.             }
  312.  
  313.             int[] CalcMP3 = new int[Shared.H/2];
  314.             for (int i = Shared.H*2; i < Shared.H*3; i++)
  315.             {
  316.                 for (int j = 0; j < Shared.N; j++)
  317.                 {
  318.                     CalcMP3[i] += B3[i] * CalcMO3[i, j];
  319.                 }
  320.             }
  321.  
  322.             for (int i = Shared.H*2; i < Shared.H*3; i++)
  323.             {
  324.                 Shared.A[i] = CalcMP3[i] + Shared.Z[i];
  325.             }
  326.             #endregion*/
  327.             Console.WriteLine($"{thread_3.Name} закончил считать и отдаёт об этом сигнал другим потокам");
  328.             Shared.T3Release.Release();
  329.  
  330.             Console.WriteLine("\nThird thread finished!");
  331.  
  332.             /*Console.Write("A = ");
  333.             for (int i = 0; i < Shared.N; i++)
  334.             {
  335.                 Console.Write($"{Shared.A[i]} ");
  336.             }*/
  337.         }
  338.     }
  339.  
  340.     class T4
  341.     {
  342.         public Thread thread_4;
  343.         public T4(string name)
  344.         {
  345.             thread_4 = new Thread(new ThreadStart(this.Run));
  346.             thread_4.Name = name;
  347.             thread_4.Start();
  348.         }
  349.         void Run()
  350.         {
  351.             Console.Write("\nFourth thread started!");
  352.  
  353.             Console.WriteLine($"{thread_4.Name} начинает вводить данные");
  354.             Console.WriteLine($"{thread_4.Name} заканчивает ввод данных данных");
  355.             Console.WriteLine($"{thread_4.Name} отдаёт сигнал про завершения ввода другим потокам");
  356.  
  357.             /*#region Ініціалізація даних
  358.             for (int i = 0; i < Shared.N; i++)
  359.             {
  360.                 for (int j = 0; j < Shared.N; j++)
  361.                 {
  362.                     Shared.MC[i, j] = 1;
  363.                 }
  364.             }
  365.             #endregion*/
  366.  
  367.             Shared.T4Data.Release();
  368.             /*Console.WriteLine($"{thread_4.Name} ждёт сигнал про завершения ввода от первого потока");
  369.             Shared.T1Data.WaitOne();
  370.             Console.WriteLine($"{thread_4.Name} получил сигнал про завершения ввода от первого потока");*/
  371.             Console.WriteLine($"{thread_4.Name} ждёт сигнал про завершения ввода от второго потока");
  372.             Shared.T2Data.WaitOne();
  373.             Console.WriteLine($"{thread_4.Name} получил сигнал про завершения ввода от второго потока");
  374.  
  375.             /*#region Копіювання даних
  376.             int[] B4 = new int[Shared.H/2];
  377.             for (int i = Shared.H*3; i < Shared.H*4; i++)
  378.             {
  379.                 B4[i] = Shared.B[i];
  380.             }*/
  381.  
  382.             //Shared.T4Data.WaitOne();
  383.  
  384.             /*int[,] MC4 = new int[Shared.H/2, Shared.N];
  385.             for (int i = Shared.H*3; i < Shared.H*4; i++)
  386.             {
  387.                 for (int j = 0; j < Shared.N; j++)
  388.                 {
  389.                     MC4[i, j] = Shared.MC[i, j];
  390.                 }
  391.             }
  392.             #endregion*/
  393.             Console.WriteLine($"{thread_4.Name} начинает копировать данные");
  394.  
  395.             Shared.T4Copy.Release();
  396.             Console.WriteLine($"{thread_4.Name} заканчивает копировать данные и отдаёт сигнал про завершение копирования другим потокам");
  397.             Shared.T4Copy.WaitOne();
  398.  
  399.             Console.WriteLine($"{thread_4.Name} принял сигнал про завершение копирования от четвёртого потока");
  400.  
  401.             /*#region Обчислення задачі
  402.             int[,] CalcMO4 = new int[Shared.H/2, Shared.N];
  403.             for (int t = Shared.H*3; t < Shared.H*4; t++)
  404.             {
  405.                 for (int i = Shared.H*3; i < Shared.H*4; i++)
  406.                 {
  407.                     for (int j = 0; j < Shared.N; j++)
  408.                     {
  409.                         CalcMO4[i, j] += MC4[i, t] * Shared.MD[t, j];
  410.                     }
  411.                 }
  412.             }
  413.  
  414.             int[] CalcMP4 = new int[Shared.H/2];
  415.             for (int i = Shared.H*3; i < Shared.H*4; i++)
  416.             {
  417.                 for (int j = 0; j < Shared.N; j++)
  418.                 {
  419.                     CalcMP4[i] += B4[i] * CalcMO4[i, j];
  420.                 }
  421.             }
  422.  
  423.             for (int i = Shared.H*3; i < Shared.H*4; i++)
  424.             {
  425.                 Shared.A[i] = CalcMP4[i] + Shared.Z[i];
  426.             }
  427.             #endregion*/
  428.             Console.Write($"{thread_4.Name} осуществляет расчёты задачи");
  429.             Console.WriteLine($"{thread_4.Name} закончил считать и отдаёт об этом сигнал другим потокам");
  430.             Shared.T4Release.Release();
  431.  
  432.             Console.WriteLine("\nFourth thread finished!");
  433.  
  434.             /*Console.Write("A = ");
  435.             for (int i = Shared.H*3; i < Shared.H*4; i++)
  436.             {
  437.                 Console.Write($"{Shared.A[i]} ");
  438.             }*/
  439.         }
  440.     }
  441.     class Program
  442.     {
  443.         static void Main(string[] args)
  444.         {
  445.             Shared shared = new Shared();
  446.             Console.WriteLine("Main started");
  447.  
  448.             T1 one = new T1("first");
  449.             T2 two = new T2("second");
  450.             T3 three = new T3("third");
  451.             T4 four = new T4("fourth");
  452.             one.thread_1.Join();
  453.             two.thread_2.Join();
  454.             three.thread_3.Join();
  455.             four.thread_4.Join();
  456.  
  457.             Console.WriteLine("\nMain finished");
  458.  
  459.             Console.ReadLine();
  460.         }
  461.     }
  462. }
Success #stdin #stdout 0.03s 26584KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Main started

First thread started!
first начинает вводить данные
first заканчивает ввод данных данных
first отдаёт сигнал про завершения ввода другим потокам
first ждёт сигнал про завершения ввода от второго потока
first получил сигнал про завершения ввода от второго потока
first ждёт сигнал про завершения ввода от четвёртого потока
first получил сигнал про завершения ввода от четвёртого потока
first начинает копировать данные
first заканчивает копировать данные и отдаёт сигнал про завершение копирования другим потокам
first принял сигнал про завершение копирования от первого потока
first осуществляет расчёты задачиfirst закончил считать и отдаёт об этом сигнал другим потокам

First thread finished!

Second thread started!second начинает вводить данные
second заканчивает ввод данных данных
second отдаёт сигнал про завершения ввода другим потокам
second ждёт сигнал про завершения ввода от четвёртого потока
second получил сигнал про завершения ввода от четвёртого потока
second начинает копировать данные
second заканчивает копировать данные и отдаёт сигнал про завершение копирования другим потокам
second ждёт сигнал про завершение копирования от второго потока
second принял сигнал про завершение копирования от второго потока
second осуществляет расчёты задачиsecond закончил считать и отдаёт об этом сигнал другим потокам

Second thread finished!

Third thread started!third ждёт сигнал про завершения ввода от второго потока
third получил сигнал про завершения ввода от второго потока
third ждёт сигнал про завершения ввода от четвёртого потока
third получил сигнал про завершения ввода от четвёртого потока
third начинает копировать данные
third заканчивает копировать данные и отдаёт сигнал про завершение копирования другим потокам
third ждёт сигнал про завершение копирования от третьего потока
third принял сигнал про завершение копирования от третьего потока
third осуществляет расчёты задачиthird закончил считать и отдаёт об этом сигнал другим потокам

Third thread finished!

Fourth thread started!fourth начинает вводить данные
fourth заканчивает ввод данных данных
fourth отдаёт сигнал про завершения ввода другим потокам
fourth ждёт сигнал про завершения ввода от второго потока
fourth получил сигнал про завершения ввода от второго потока
fourth начинает копировать данные
fourth заканчивает копировать данные и отдаёт сигнал про завершение копирования другим потокам
fourth принял сигнал про завершение копирования от четвёртого потока
fourth осуществляет расчёты задачиfourth закончил считать и отдаёт об этом сигнал другим потокам

Fourth thread finished!

Main finished
https://ideone.com/IV18E2
language:
C# (gmcs 5.20.1)
created:
4 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!