3.3 Завершение потоков

Потоки могут быть запущены и остановлены сколько угодно раз в процессе их выполнения. Для временной остановки запущенного потока можно обратиться к методу потока suspend. Для продолжения выполнения приостановленного потока вызовите метод потока Resume. Вы можете использовать вложенные вызовы вышеперечисленных методов, т. к. метод Suspend увеличивает внутренний счетчик потока, a Resume уменьшает. Поток не будет выполняться до тех пор, пока счетчик не обратиться в ноль, т. е., если вы вызвали пять раз метод Suspend, а затем четыре раза Resume, вам понадобится еще один (пятый) вызов метода Resume для продолжения выполнения потока.

Выполнение потока автоматически завершается после завершения функции Execute() или закрытии приложения.

Чтобы занятая потоком память освобождалась при завершении потока надо установить FreeOnTerminate=false.

 

4 Листинг программы

Файл 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]); //разрешаем параллельную обработку

}