Диаграмма 1 выполнение потоков

При нажатии кнопки «START», считываются данные с полей «N» и «Time», создаются новые объекты потоков и отправляется сигнал на их запуск. интерфейс алгоритм синхронизация массив

Перед тем как поток будет выполнять вычисления, он ожидает сигнал об активизации объекта событие. На время вычислений (блок-схемы 1, 2, 3) событие переходит в состояние пассивное. По завершению обработки вычислений событие переходит в состояние активное. За счет этого достигается синхронизация между потоками.

При закрытии программы или нажатии кнопки «STOP» потоки уничтожаются.

Диаграмма 1, показывает состояние потоков в течение времени выполнения.

1.2 Интерфейса программы

На главной форме располагается группа компонентов для ввода и вывода значений:

- Три поля (Thread1, Thread2, Thread3) для вывода значений

- «N» указывает размерность массива

- «Time» количество времени, через которое будут выводиться результаты в текстовые поля (Thread1, Thread2, Thread3).

Кнопка «START» создает потоки, в которых происходит вычисления среднего арифметического каждой тройки чисел массива и произведений каждого числа на его номер (индекс). Результаты выводятся на главной форме в поля (Thread1, Thread2, Thread3).

Кнопка «STOP» останавливает запущенные потоки.

Кнопка «EXIT» закрывает программу, при запущенных потоках уничтожает их.

Рисунок 1 Главная форма

2. Описание методов решения и алгоритмов задач, реализуемых каждым потоком

2.1 Метод заполнения массива случайными числами

Блок-схема 1 Заполнение массива случайными числами от -999 до 999

2.2 Метод вычисления минимальных и максимальных значений

Пример 1. Дан массив A = {-359, 126, 803, 913, -716};

Решение:

Начальные значения min = 0, max = -359;

Блок схема 3 Вычисление минимального и максимального значения

Ответ: min = -716, max = 913.

2.3 Метод вычисления отклонений каждого значения от среднего арифметического

Для вычисления отклонений всех чисел выполним следующие действия:

1. Находим среднее арифметическое;

2. Для вычисления отклонение из данного набора чисел вычитаем среднее арифметическое.

Среднее арифметическое нескольких величин -- это отношение суммы величин к их количеству. Среднее арифметическое находится по формуле

Пример 2. Дан массив A = {-359, 126, 803, 913, -716};

Блок схема 2 Вычисление отклонений каждого значения от среднего арифметического

Найти отклонений всех чисел от среднего арифметического.

Решение:

Сумма чисел в массиве (2):

Вычисление отклонения (3):

3. Описание методов создания, уничтожения и синхронизации потоков, примененных в программе

3.1 Создание потоков

Для создания многопоточных приложений в C++Builder реализован абстрактный класс TThread. TThread абстрактный класс, который допускает создание отдельных потоков выполняющихся в приложении. Создайте потомка класса TThread, чтобы представить выполняемый поток в многопоточном приложении.

Каждый новый экземпляр потомка TThread новый поток выполнения. Множество экземпляров, полученные от класса TThread , делает C++Builder многопоточным приложением.

__fastcall TMyThread::TMyThread(bool CreateSuspended)

: TThread(CreateSuspended)

{

}

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

// B метод объекта Execute(), вставьте код, который должен выполняться, когда поток выполняется.

void __fastcall TMyThread::Execute()

{

//---Place thread code here ----

}

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

Для получения безопасного доступа к управлению свойствами и методами VCL-объектов в потоке предусмотрен метод Synchronize()

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

void __fastcall ThreadLenghtLine::Execute()

{

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

int ColN = N/6;

while (true){

sum = 0;

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

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

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

for (int i = 0; i<ColN*6;) { //считаем длину

sum += CalcLengthLine(FMain->A[i++], FMain->A[i++], FMain->A[i++], FMain->A[i++], FMain->A[i++], FMain->A[i++]);

}

count++;

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

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

Sleep(T*1000);

}

}

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

void __fastcall ThreadLenghtLine::Mon()

{

FLenghtLine->RELenghtLine->Lines->Add(IntToStr(count) + ") " + FloatToStr(sum));

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

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

}

3.2 Синхронизация потоков

Синхронизации потоков основывается на использовании событий (event). Объект типа событие может принимать одно из двух состояний: активное или пассивное. Когда событие находится в активном состоянии, его видят многие потоки одновременно. В результате такой объект можно использовать для управления работой сразу многих потоков. В библиотеке VCL события представлены классом TEvent.

Метод CreatEvents(): Создает объект класса TEvent, представляющий объект события.

Метод ResetEvent(): Переводит объект события в пассивное состояние.

Метод SetEvent() : Переводит объект события в активное состояние.

WaitForSingleObject(): Заставляет ждать, пока другой поток или процесс не пошлют сигнал об активизации объекта событие.

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

}

Заключение

В процессе работы над курсовым проектом были изучены основы многопоточного программирования в Windows с использованием библиотеки визуальных компонентов (VCL) Builder C++.

1) Создание потоков.

2) Синхронизация потоков.

3) Уничтожение потоков

В результате было разработано многопоточное приложение которое создает в первом потоке случайный массив А из N целых чисел в диапазоне от -999 до 999 выводит на экран эти числа.

Во втором потоке определяется минимальные и максимальные значений

В третьем потоке вычисляется отклонение всех чисел среднего арифметического.

Все потоки выводят результаты своей работы в текстовые поля, каждый поток в свое поле.

Синхронизация потоков осуществлялась на основе событий.

Список использованной литературы

1. Методические указания к курсовой работе по дисциплине «ОПЕРАЦИОННЫЕ СИСТЕМЫ» для студентов 3-го курса специальности 230102 АСОИУ/ составитель: к.т.н., доц. В.Н. Цыганенко.

2. Рихтер Дж. Windows для профессионалов. Создание эффективных Win32-приложений с учетом специфики 64-разрядной версии Windows / Пер. с англ. - 4-е изд. - Спб.: Питер; М.: Изд-во «Русская редакция»; 2008. - 720 тр.

3. А.Я. Архангельский С++ Builder 6 Книга 1 Язык C++ .. БИНОМ 2002 г.

Размещено на Allbest.ru