Использование потоков в приложениях Windows

Описание общего алгоритма и интерфейса программы. Метод заполнения массива случайными числами. Метод вычисления длины линии между пространственными точками. Создание, синхронизация и завершение потоков. TThread как абстрактный класс, листинг программы.

Рубрика Программирование, компьютеры и кибернетика
Вид курсовая работа
Язык русский
Дата добавления 08.04.2014
Размер файла 664,0 K

Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже

Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.

Размещено на http://www.allbest.ru/

[Введите текст]

Министерство образования и науки

Государственное образовательное учреждение высшего профессионального образования

«ОМСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ»

Кафедра «Автоматизированные системы обработки информации и управления»

Курсовая работа

Использование потоков в приложениях Windows

Омск 2014

Задание

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

Задание B

Задание C

Вычисление минимального и максимального значений

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

1. Описание общего алгоритма и интерфейса программы

1.1 Описание общего алгоритма

Размещено на http://www.allbest.ru/

[Введите текст]

Диаграмма 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 Метод заполнениямассива случайными числами

Размещено на http://www.allbest.ru/

[Введите текст]

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

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

Размещено на http://www.allbest.ru/

[Введите текст]

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

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

Решение:

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

A[1]

-359

126

803

913

-716

-359 < min(0) ; min = -359

-359 > max(-359); max = -359

A[2]

-359

126

803

913

-716

126 < min(-359); min = -359

126 > max(-359); max = 126

A[3]

-359

126

803

913

-716

803 < min(-359); min = -359

803 > max(126); max = 803

A[4]

-359

126

803

913

-716

913 < min(-359); min = -359

913 > max(803); max = 913

A[5]

-359

126

803

913

-716

-716 < min(-359); min = -716

-716 > max(803); max = 913

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

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

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

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

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

Среднее арифметическое находится по формуле

(2)

(3)

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

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

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

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

Размещено на http://www.allbest.ru/

[Введите текст]

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

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

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

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

TThread - абстрактный класс, который допускает создание отдельных потоков выполняющихся в приложении.

Создайте потомка класса TThread, чтобы представить выполняемый поток в многопоточном приложении.

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

программа интерфейс массив поток

__fastcallTMyThread::TMyThread(boolCreateSuspended)

: TThread(CreateSuspended)

{

}

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

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

void __fastcallTMyThread::Execute()

{

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

}

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

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

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

void __fastcallThreadLenghtLine::Execute()

{

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

intColN = 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 __fastcallThreadLenghtLine::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;

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

__fastcallTFMain::TFMain(TComponent* Owner)

: TForm(Owner)

{

}

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

void __fastcallTFMain::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 = newThreadCreatMassiv(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 __fastcallTFMain::btnStopClick(TObject *Sender)

{

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

thread2->Suspend();

thread3->Suspend();

}

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

void __fastcallTFMain::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 __fastcallThreadCreatMassiv::UpdateCaption()

// {

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

// }

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

__fastcallThreadCreatMassiv::ThreadCreatMassiv(boolCreateSuspended)

: TThread(CreateSuspended)

{

}

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

void __fastcallThreadCreatMassiv::Execute()

{

intmin = -999;

intmax = 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 __fastcallThreadCreatMassiv::Sinchr()

{

AnsiStringrezult;

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 __fastcallThreadSredZnach::UpdateCaption()

// {

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

// }

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

__fastcallThreadMinMax::ThreadMinMax(boolCreateSuspended)

: TThread(CreateSuspended)

{

}

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

void __fastcallThreadMinMax::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 __fastcallThreadMinMax::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 __fastcallThreadIndex::UpdateCaption()

// {

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

// }

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

__fastcallThreadIndex::ThreadIndex(boolCreateSuspended)

: TThread(CreateSuspended)

{

}

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

void __fastcallThreadIndex::Execute()

{

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

inttN = 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 __fastcallThreadIndex::Sinhr(){

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

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

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

}

Заключение

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

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


Подобные документы

  • Разработка программы, которая создает в отдельном потоке случайный массив целых чисел в заданном диапазоне и выводит на экран эти числа. Описание общего алгоритма, интерфейс программы. Методы решения и алгоритмы задач, реализуемых каждым потоком.

    курсовая работа [372,6 K], добавлен 17.04.2014

  • Сведения об окружности, ее радиус и площадь. Разработка программы для вычисления площади круга и длины окружности по заданному радиусу с использованием Windows.Forms-приложений. Пошаговая инструкция; описание главного окна, код, примеры работы программы.

    курсовая работа [818,6 K], добавлен 14.09.2014

  • Сущность понятий: "куча" (пул памяти), связный список, синхронизация потоков; разработка программы, исключающей возможность перекрытия потоков друг другом. Организация связных списков и использование функций API для работы с пулом памяти в ОС Windows.

    курсовая работа [145,3 K], добавлен 11.05.2012

  • Решения задачи графическим и программным способами. Описание алгоритма решения графическим способом, укрупненная схема алгоритма. Ввод элементов двумерного массива, вывод преобразованного массива, разработка программы на языке pascal, листинг программы.

    курсовая работа [115,5 K], добавлен 22.05.2010

  • Основы программирования на 32-битном Ассемблере, разработка с его помощью программы, демонстрирующей работу одного из разделов ОС Windоws. Описание используемых АРI-функций как интерфейса программирования приложений. Листинг программы, результаты работы.

    курсовая работа [164,5 K], добавлен 18.05.2014

  • Написание прикладного Windows-приложения на примере программы-органайзера, позволяющей вести электронный ежедневник и телефонную записную книжку. Описание блок-схемы программы и операционной системы. Листинг результатов обработки на контрольном примере.

    дипломная работа [2,5 M], добавлен 29.12.2014

  • Разработка программы на языке Pascal. Описание переменных. Действия, которые должна выполнить программа согласно выбранного алгоритма. Детализация графической части программы. Листинг и тестирование программы. Вывод массива данных на экран монитора.

    контрольная работа [360,4 K], добавлен 13.06.2012

  • Использование массива данных о сотрудниках небольшой фирмы для создания программы. Введение информации, ее хранение в файле workers.dat. Процедуры и функции программы, дополнительные файлы, описание предметной области и алгоритма задачи, листинг.

    курсовая работа [22,0 K], добавлен 29.11.2009

  • Описание алгоритма решения задачи графическим способом. Вывод элементов массива. Описание блоков укрупненной схемы алгоритма на языке Pascal. Листинг программы, а также ее тестирование. Результат выполнения c помощью ввода различных входных данных.

    контрольная работа [150,4 K], добавлен 03.05.2014

  • Разработка блок-схемы и программы обработки одномерного массива с доступом к элементам с помощью индексов и с помощью указателей. Словесное описание алгоритма и пользовательского интерфейса, листинг программы обработки матрицы и результат её выполнения.

    курсовая работа [391,1 K], добавлен 30.09.2013

Работы в архивах красиво оформлены согласно требованиям ВУЗов и содержат рисунки, диаграммы, формулы и т.д.
PPT, PPTX и PDF-файлы представлены только в архивах.
Рекомендуем скачать работу.