Файл UMain. cpp

#include <vcl. h>

#pragma hdrstop

#include "UMain. h"

#include "UThread1. h"

#include "UThread2. h"

#include "UThread3. h"

// ---------------------------------------------------------------------------

#pragma package (smart_init)

#pragma resource "*. dfm"

TFMain *FMain;

ThreadCreatMassiv *thread1;

ThreadMinMax *thread2;

ThreadIndex *thread3;

// ---------------------------------------------------------------------------

__fastcall TFMain:: TFMain (TComponent* Owner)

: TForm (Owner)

{

}

// ---------------------------------------------------------------------------

void __fastcall TFMain:: btnStartClick (TObject *Sender)

{

if (eN->Text == "" || eT->Text == "") {

StatusBar1->Panels->Items [0] - >Text="Заполните все поля";

}else{

StatusBar1->Panels->Items [0] - >Text="";

reThread1->Clear ();

reThread2->Clear ();

reThread3->Clear ();

g_Event [0] = CreateEvent (NULL, FALSE, FALSE, NULL); // Создаём событие

g_Event [1] = CreateEvent (NULL, FALSE, TRUE, NULL); // Создаём событие

SetEvent (g_Event [0]); // разрешаем формирование

ResetEvent (g_Event [1]); // запрещаем обработки

thread1 = new ThreadCreatMassiv (true); // создаем поток в приостановленном состоянии (true)

thread1->N = StrToInt (eN->Text); // Передача параметров потоку

thread1->T = StrToInt (eT->Text);

thread1->Resume (); // Возобновляет работу приостановленного потока

thread2 = new ThreadMinMax (true);

thread2->N = StrToInt (eN->Text);

thread2->T = StrToInt (eT->Text);

thread2->Resume ();

thread3 = new ThreadIndex (true);

thread3->N = StrToInt (eN->Text);

thread3->T = StrToInt (eT->Text);

thread3->Resume ();

}

}

// ---------------------------------------------------------------------------

void __fastcall TFMain:: btnStopClick (TObject *Sender)

{

thread1->Suspend (); // Приостанавливает работу потока

thread2->Suspend ();

thread3->Suspend ();

}

// ---------------------------------------------------------------------------

void __fastcall TFMain:: btnExitClick (TObject *Sender)

{

FMain->Close ();

}

// ---------------------------------------------------------------------------

Файл UThread1. cpp

#include <vcl. h>

#pragma hdrstop

#include "UThread1. h"

#include "UMain. h"

#include "UThread2. h"

#pragma package (smart_init)

// ---------------------------------------------------------------------------

// Important: Methods and properties of objects in VCL can only be

// used in a method called using Synchronize, for example:

//

// Synchronize (&UpdateCaption);

//

// where UpdateCaption could look like:

//

// void __fastcall ThreadCreatMassiv:: UpdateCaption ()

// {

// Form1->Caption = "Updated in a thread";

// }

// ---------------------------------------------------------------------------

__fastcall ThreadCreatMassiv:: ThreadCreatMassiv (bool CreateSuspended)

: TThread (CreateSuspended)

{

}

// ---------------------------------------------------------------------------

void __fastcall ThreadCreatMassiv:: Execute ()

{

int min = - 999;

int max = 999;

FreeOnTerminate = true; // освободить занятую потоком память по окончании его работы

while (true) {

WaitForSingleObject (FMain->g_Event [0], INFINITE);

ResetEvent (FMain->g_Event [1]); // запрещаем переформирование массива

ResetEvent (FMain->g_Event [0]); // запрещаем переформирование массива

srand (time (NULL));

for (int i = 0; i < N; i++) {

FMain->A [i] = rand () % (min - max) + min; // заполняем массив рандомными числами

}

count++;

if (Terminated) break; // прекратить извне поток

Synchronize (&Sinchr); // блокирует одновременный доступ к компоненту нескольких потоков

Sleep (T*1000);

}

// ---------------------------------------------------------------------------

}

void __fastcall ThreadCreatMassiv:: Sinchr ()

{

AnsiString rezult;

for (int i = 0; i < N; i++) {

rezult += IntToStr (FMain->A [i]) +", ";

SetEvent (FMain->g_Event [0]); // разрешаем параллельную обработку

SetEvent (FMain->g_Event [1]); // разрешаем параллельную обработку

}

FMain->reThread1->Lines->Add (IntToStr (count) + ")" + rezult); // вывод результатов вычисления

Файл Thread2. cpp

#include <vcl. h>

#pragma hdrstop

#include "UThread2. h"

#include "UMain. h"

#include "UThread1. h"

#pragma package (smart_init)

// ---------------------------------------------------------------------------

// Important: Methods and properties of objects in VCL can only be

// used in a method called using Synchronize, for example:

//

// Synchronize (&UpdateCaption);

//

// where UpdateCaption could look like:

//

// void __fastcall ThreadSredZnach:: UpdateCaption ()

// {

// Form1->Caption = "Updated in a thread";

// }

// ---------------------------------------------------------------------------

__fastcall ThreadMinMax:: ThreadMinMax (bool CreateSuspended)

: TThread (CreateSuspended)

{

}

// ---------------------------------------------------------------------------

void __fastcall ThreadMinMax:: Execute ()

{

FreeOnTerminate = true; // освободить занятую потоком память по окончании его работы

while (true) {

WaitForSingleObject (FMain->g_Event [1], INFINITE); // ждём разрешение на обработку

ResetEvent (FMain->g_Event [1]); // запрещаем переформирование массива

ResetEvent (FMain->g_Event [0]); // запрещаем переформирование массива

max = 0;

min = 0;

max = FMain->A [0];

for (int i = 0; i<N; i++) {

if (FMain->A [i] < min)

{

min = FMain->A [i];

}

if (FMain->A [i] > max)

{

max = FMain->A [i];

}

}

count++;

if (Terminated) break; // прекратить извне поток

Synchronize (&Sinhr); // блокирует одновременный доступ к компоненту нескольких потоков

Sleep (T*1000);

}

}

// ---------------------------------------------------------------------------

void __fastcall ThreadMinMax:: Sinhr ()

{

FMain->reThread2->Lines->Add (IntToStr (count) + ")" + "max = " + max +", min = " + min); // вывод результатов вычисления

SetEvent (FMain->g_Event [0]); // разрешаем параллельную обработку

SetEvent (FMain->g_Event [1]); // разрешаем параллельную обработку

}

Файл UThread3. cpp

#include <vcl. h>

#pragma hdrstop

#include "UThread3. h"

#include "UMain. h"

#include "UThread1. h"

#include "UThread2. h"

#pragma package (smart_init)

// ---------------------------------------------------------------------------

// Important: Methods and properties of objects in VCL can only be

// used in a method called using Synchronize, for example:

//

// Synchronize (&UpdateCaption);

//

// where UpdateCaption could look like:

//

// void __fastcall ThreadIndex:: UpdateCaption ()

// {

// Form1->Caption = "Updated in a thread";

// }

// ---------------------------------------------------------------------------

__fastcall ThreadIndex:: ThreadIndex (bool CreateSuspended)

: TThread (CreateSuspended)

{

}

// ---------------------------------------------------------------------------

void __fastcall ThreadIndex:: Execute ()

{

FreeOnTerminate = true; // освободить занятую потоком память по окончании его работы

int tN = N/3;

while (true) {

WaitForSingleObject (FMain->g_Event [1], INFINITE); // ждём разрешение на обработку

ResetEvent (FMain->g_Event [1]); // запрещаем переформирование массива

ResetEvent (FMain->g_Event [0]); // запрещаем переформирование массива

rezult = "";

for (int i = 0; i < N; i++) {

sum += FMain->A [i]; // сумма всех элементов массива

}

arg = sum/N; // среднее арифмитическое

for (int i = 0; i < N; i++) {

raz = arg - FMain->A [i]; // отклонение каждого числа

rezult += FloatToStr (raz) +", ";

}

count++;

if (Terminated) break; // прекратить извне поток

Synchronize (&Sinhr); // блокирует одновременный доступ к компоненту нескольких потоков

Sleep (T*1000);

}

}

// ---------------------------------------------------------------------------

void __fastcall ThreadIndex:: Sinhr () {

FMain->reThread3->Lines->Add (IntToStr (count) + ")" + rezult); // вывод результатов вычисления

SetEvent (FMain->g_Event [0]); // разрешаем параллельную обработку

SetEvent (FMain->g_Event [1]); // разрешаем параллельную обработку

Заключение