Модель логически упорядоченных процессов

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

ЧОУ ВПО “Южно-Уральский институт управления и экономики”

Кафедра “Информационные технологии и системы”

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

Модель логически упорядоченных процессов

Выполнил: Тройнов Евгений Александрович

Группа: ПС - 504

Проверил(а): Мухина Юлия Рамильевна.

Челябинск, 2012

Содержание

Введение

1. Теоретическая часть

1.1 Процессы

1.2 Потоки

1.3 Многопоточность

2. Практическая часть

2.1 Взаимодействие потоков

2.2 Реализация потоков в Delphi

2.3 Программа, реализующая пример многопоточного приложения

Заключение

Список литературы

Приложение



Введение

Целью курсовой работы является изучение различных способов реализации много поточности в языках программирования и операционных системах, и разработка прототипа приложения реализующего многопоточность.

Долгое время повышение производительности традиционных одноядерных процессоров в основном происходило за счет последовательного увеличения тактовой частоты (около 80% производительности процессора определяла именно тактовая частота) с одновременным увеличением количества транзисторов на одном кристалле. Однако дальнейшее повышение тактовой частоты упирается в ряд фундаментальных физических барьеров (поскольку технологический процесс почти вплотную приблизился к размерам атома: сегодня процессоры выпускаются по 45-нм технологии, а размеры атома кремния - приблизительно 0,543 нм):

· во-первых, с уменьшением размеров кристалла и с повышением тактовой частоты возрастает ток утечки транзисторов. Это ведет к повышению потребляемой мощности и увеличению выброса тепла;

· во-вторых, преимущества более высокой тактовой частоты частично сводятся на нет из-за задержек при обращении к памяти, так как время доступа к памяти не соответствует возрастающим тактовым частотам;

· в-третьих, для некоторых приложений традиционные последовательные архитектуры становятся неэффективными с возрастанием тактовой частоты из-за так называемого «фон-неймановского узкого места» - ограничения производительности в результате последовательного потока вычислений. При этом возрастают резистивно-емкостные задержки передачи сигналов, что является дополнительным узким местом, связанным с повышением тактовой частоты.

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

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

Цель курсовой работы изучить реализацию и использование многопоточности.

Задачи:

1. Изучить теоретические вопросы по проблеме использования потоков и процессов

2. Рассмотреть способы реализации многопоточности в Delphi

Создать приложение в Delphi реализующее многопоточность типа N:1 (потоки выполнения уровня пользователя).



1. Теоретическая часть

1.1 Процесс

Процесс -- выполнение пассивных инструкций компьютерной программы на процессоре ЭВМ. Стандарт ISO 9000:2000 Definitions определяет процесс как совокупность взаимосвязанных и взаимодействующих действий, преобразующих входящие данные в исходящие. Компьютерная программа сама по себе это только пассивная совокупность инструкций, в то время как процесс -- это непосредственное выполнение этих инструкций. Часто процессом называют выполняющуюся программу и все её элементы: адресное пространство, глобальные переменные, регистры, стек, открытые файлы и т. д.

1. Создание процесса.

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

Обычно они создаются:

· При запуске ОС.

· При появлении запроса на создание процесса -- происходит в случае, если работающий процесс создает новый процесс.

2. Завершение процесса.

Минимум 2 этапа завершения:

· Процесс удаляется из всех очередей планирования, т.е. ОС больше не планирует выделение каких-либо ресурсов процессу

· Сбор статистики о потреблённых процессом ресурсов с последующим удалением его из памяти

Причины завершения процесса:

· Обычный выход

· Выход по исключению или ошибке

· Недостаточный объем памяти

· Превышение лимита отведённого программе времени

· Выход за пределы отведённой области памяти

· Неверная команда (данные интерпретируются как команды)

· Ошибка защиты

· Завершение родительского процесса

· Ошибка ввода/вывода

· Вмешательство оператора

1.2 Потоки

Поток (англ. Thread -- нить) - является наименьшей единицей обработки, исполнение которой может быть назначено операционной системой. Реализация потоков выполнения и процессов в разных операционных системах отличается друг от друга, но в большинстве случаев поток выполнения находится внутри процесса. Несколько потоков выполнения могут существовать в рамках одного и того же процесса и совместно использовать ресурсы, такие как память, тогда как процессы не разделяют этих ресурсов. В частности, потоки выполнения разделяют инструкции процесса (его код) и его контекст (значения переменных, которые они имеют в любой момент времени). На одном процессоре Многопоточность обычно происходит путём временного мультиплексирования (как и в случае многозадачности): процессор переключается между разными потоками выполнения. Это переключение контекста обычно происходит достаточно часто, чтобы пользователь воспринимал выполнение потоков или задач как одновременное. В многопроцессорных и многоядерных системах потоки или задачи могут реально выполняться одновременно, при этом каждый процессор или ядро обрабатывает отдельный поток или задачу. Многие современные операционные системы поддерживают как временные нарезки от планировщика процессов, так и многопроцессорные потоки выполнения. Ядро операционной системы позволяет программистам управлять потоками выполнения через интерфейс системных вызовов. Некоторые реализации ядра называют потоком ядра, другие же -- лёгким процессом (англ. light-weight process, LWP), представляющим собой особый тип потока выполнения ядра, который совместно использует одни и те же состояния и данные. Программы могут иметь пользовательское пространство потоков выполнения при создании потоков с помощью таймеров, сигналов или другими методами, позволяющими прервать выполнение и создать временную нарезку для конкретной ситуации (Ad hoc).

1. Отличие потоков выполнения от процессов.

Потоки выполнения отличаются от традиционных процессов многозадачной операционной системы тем, что:

· процессы, как правило, независимы, тогда как потоки выполнения существуют как составные элементы процессов

· процессы несут значительно больше информации о состоянии, тогда как несколько потоков выполнения внутри процесса совместно используют информацию о состоянии, а также память и другие вычислительные ресурсы

· процессы имеют отдельные адресные пространства, тогда как потоки выполнения совместно используют их адресное пространство

· процессы взаимодействуют только через предоставляемые системой механизмы связей между процессами

· переключение контекста между потоками выполнения в одном процессе, как правило, быстрее, чем переключение контекста между процессами.

· Такие системы, как Windows NT и OS/2, как говорят, имеют «дешёвые» потоки выполнения и «дорогие» процессы. В других операционных системах разница между потоками выполнения и процессами не так велика, за исключением расходов на переключение адресного пространства, которое подразумевает использование буфера ассоциативной трансляции.

1.3 Многопоточность

Многопоточность -- свойство платформы (например, операционной системы, виртуальной машины и т. д.) или приложения, состоящее в том, что процесс, порождённый в операционной системе, может состоять из нескольких потоков, выполняющихся «параллельно», то есть без предписанного порядка во времени. При выполнении некоторых задач такое разделение может достичь более эффективного использования ресурсов вычислительной машины. Такие потоки называют также потоками выполнения (от англ. thread of execution); иногда называют «нитями» (буквальный перевод англ. thread) или неформально «тредами». Сутью многопоточности является квазимногозадачность на уровне одного исполняемого процесса, то есть все потоки выполняются в адресном пространстве процесса. Кроме этого, все потоки процесса имеют не только общее адресное пространство, но и общие дескрипторы файлов. Выполняющийся процесс имеет как минимум один (главный) поток. Многопоточность (как доктрину программирования) не следует путать ни с многозадачностью, ни с многопроцессорностью, несмотря на то, что операционные системы, реализующие многозадачность, как правило реализуют и многопоточность.

К достоинствам многопоточности в программировании можно отнести следующее:

· Упрощение программы в некоторых случаях, за счет использования общего адресного пространства.

· Меньшие относительно процесса временные затраты на создание потока.

· Повышение производительности процесса за счет распараллеливания процессорных вычислений и операций ввода/вывода.

1. Типы реализации потоков.

Поток в пространстве пользователя. Каждый процесс имеет таблицу потоков, аналогичную таблице процессов ядра.

Недостатки:

1. Отсутствие прерывания по таймеру внутри одного процесса

2. При использовании блокирующего системного запроса для процесса все его потоки блокируются.

3. Сложность реализации

4. Поток в пространстве ядра. Наряду с таблицей процессов в пространстве ядра имеется таблица потоков.

«Волокна» (англ. fibers). Несколько потоков режима пользователя, исполняющихся в одном потоке режима ядра. Поток пространства ядра потребляет заметные ресурсы, в первую очередь физическую память и диапазон адресов режима ядра для стека режима ядра. Поэтому было введено понятие «волокна» -- облегчённого потока, выполняемого исключительно в режиме пользователя. У каждого потока может быть несколько «волокон».

2. Модели потоков.

1:1 (Потоки выполнения на уровне ядра)

Потоки выполнения, созданные пользователем в модели 1-1, соответствуют диспетчируемым сущностям ядра. Это простейший возможный вариант реализации потоковости. В Windows API этот подход использовался с самого начала. В Linux обычная библиотека C реализует этот подход (через библиотеку потоков POSIX, а в более старших версиях через LinuxThreads). Такой же подход используется ОС Solaris, NetBSD и FreeBSD.

N:1 (Потоки выполнения уровня пользователя)

В модели N:1 предполагается, что все потоки выполнения уровня пользователя отображаются на единую планируемую сущность уровня ядра, и ядро ничего не знает о составе прикладных потоков выполнения. При таком подходе переключение контекста может быть сделано очень быстро, и, кроме того, он может быть реализован даже на простых ядрах, которые не поддерживают многопоточность. Однако, одним из главных недостатков его является то, что в нём нельзя извлечь никакой выгоды из аппаратного ускорения на многопоточных процессорах или многопроцессорных компьютерах, потому что только один поток выполнения может быть запланирован на любой момент времени. Эта модель используется в GNU Portable Threads.

M:N (Смешанная потоковость)

В модели M:N некоторое число N прикладных потоков выполнения отображаются на некоторое число M сущностей ядра или «виртуальных процессоров». Модель является компромиссной между моделью уровня ядра («1:1») и моделью уровня пользователя («N:1»). Вообще говоря, «M:N» потоковость системы являются более сложной для реализации, чем ядро или пользовательские потоки выполнения, поскольку изменение кода как для ядра, так и для пользовательского пространства не требуется. В M:N реализации библиотека потоков отвечает за планирование пользовательских потоков выполнения на имеющихся планируемых сущностях. При этом переключение контекста потоков делается очень быстро, поскольку модель позволяет избежать системных вызовов. Тем не менее, увеличивается сложность и вероятность инверсии приоритетов, а также неоптимальность планирования без обширной (и дорогой) координации между пользовательским планировщиком и планировщиком ядра.



2. Практическая часть

2.1 Взаимодействие потоков

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

1. Взаимоисключения (mutex, мьютекс) -- это объект синхронизации, который устанавливается в особое сигнальное состояние, когда не занят каким-либо потоком. Только один поток владеет этим объектом в любой момент времени, отсюда и название таких объектов (от английского mutually exclusive access -- взаимно исключающий доступ) -- одновременный доступ к общему ресурсу исключается. После всех необходимых действий мьютекс освобождается, предоставляя другим потокам доступ к общему ресурсу. Объект может поддерживать рекурсивный захват второй раз тем же потоком, увеличивая счетчик, не блокируя поток, и требуя потом многократного освобождения. Таков, например, mutex в Win32 и KMUTEX в ядре Windows. Тем не менее есть и такие реализации, которые не поддерживают такое и приводят к взаимной блокировке потока при попытке рекурсивного захвата. Это FAST_MUTEX в ядре Windows и критическая секция в Win32.

2. Семафоры представляют собой доступные ресурсы, которые могут быть приобретены несколькими потоками в одно и то же время, пока пул ресурсов не опустеет. Тогда дополнительные потоки должны ждать, пока требуемое количество ресурсов не будет снова доступно. Семафоры очень эффективны, поскольку они позволяют одновременный доступ к ресурсам. Семафор есть логическое расширение мьютекса -- семафор со счетчиком 1 эквивалентен мьютексу, но счетчик может быть и более 1.

3. События. Объект, хранящий в себе 1 бит информации «просигнализирован или нет», над которым определены операции «просигнализировать», «сбросить в непросигнализированное состояние» и «ожидать». Ожидание на просигнализированном событии есть отсутствие операции с немедленным продолжением исполнения потока. Ожидание на непросигнализированном событии приводит к приостановке исполнения потока до тех пор, пока другой поток (или же вторая фаза обработчика прерывания в ядре ОС) не просигнализирует событие. Возможно ожидание нескольких событий в режимах «любого» или «всех». Возможно также создания события, автоматически сбрасываемого в непросигнализированное состояние после пробуждения первого же -- и единственного -- ожидающего потока (такой объект используется как основа для реализации объекта «критическая секция»). Активно используются в MS Windows, как в режиме пользователя, так и в режиме ядра. Аналогичный объект имеется и в ядре Linux под названием kwait_queue.

4. Критические секции обеспечивают синхронизацию подобно мьютексам за исключением того, что объекты, представляющие критические секции, доступны в пределах одного процесса. События, мьютексы и семафоры также можно использовать в однопроцессном приложении, однако реализации критических секций в некоторых ОС (например, Windows NT) обеспечивают более быстрый и более эффективный механизм взаимно-исключающей синхронизации -- операции «получить» и «освободить» на критической секции оптимизированы для случая единственного потока (отсутствия конкуренции) с целью избежать любых ведущих в ядро ОС системных вызовов. Подобно мьютексам объект, представляющий критическую секцию, может использоваться только одним потоком в данный момент времени, что делает их крайне полезными при разграничении доступа к общим ресурсам.

5. Условные переменные (condvars). Сходны с событиями, но не являются объектами, занимающими память -- используется только адрес переменной, понятие «содержимое переменной» не существует, в качестве условной переменной может использоваться адрес произвольного объекта. В отличие от событий, установка условной переменной в просигнализированное состояние не влечет за собой никаких последствий в случае, если на данный момент нет потоков, ожидающих на переменной. Установка события в аналогичном случае влечет за собой запоминание состояния «просигнализировано» внутри самого события, после чего следующие потоки, желающие ожидать события, продолжают исполнение немедленно без остановки. Для полноценного использования такого объекта необходима также операция «освободить mutex и ожидать условную переменную атомарно». Активно используются в UNIX-подобных ОС. Дискуссии о преимуществах и недостатках событий и условных переменных являются заметной частью дискуссий о преимуществах и недостатках Windows и UNIX.

6. Порт завершения ввода-вывода (IO completion port, IOCP). Реализованный в ядре ОС и доступный через системные вызовы объект «очередь» с операциями «поместить структуру в хвост очереди» и «взять следующую структуру с головы очереди» -- последний вызов приостанавливает исполнение потока в случае, если очередь пуста, и до тех пор, пока другой поток не осуществит вызов «поместить». Самой важной особенностью IOCP является то, что структуры в него могут помещаться не только явным системным вызовом из режима пользователя, но и неявно внутри ядра ОС как результат завершения асинхронной операции ввода-вывода на одном из дескрипторов файлов. Для достижения такого эффекта необходимо использовать системный вызов «связать дескриптор файла с IOCP». В этом случае помещенная в очередь структура содержит в себе код ошибки операции ввода-вывода, а также, для случая успеха этой операции -- число реально введенных или выведенных байт. Реализация порта завершения также ограничивает число потоков, исполняющихся на одном процессоре/ядре после получения структуры из очереди. Объект специфичен для MS Windows, и позволяет обработку входящих запросов соединения и порций данных в серверном программном обеспечении в архитектуре, где число потоков может быть меньше числа клиентов (нет требования создавать отдельный поток с расходами ресурсов на него для каждого нового клиента).

7. ERESOURCE. Мьютекс, поддерживающий рекурсивный захват, с семантикой разделяемого или эксклюзивного захвата. Семантика: объект может быть либо свободен, либо захвачен произвольным числом потоков разделяемым образом, либо захвачен всего одним потоком эксклюзивным образом. Любые попытки осуществить захваты, нарушающее это правило, приводят к блокировке потока до тех пор, пока объект не освободится так, чтобы сделать захват разрешенным. Также есть операции вида TryToAcquire -- никогда не блокирует поток, либо захватывает, либо (если нужна блокировка) возвращает FALSE, ничего не делая. Используется в ядре Windows, особенно в файловых системах -- так, например, любому кем-то открытому дисковому файлу соответствует структура FCB, в которой есть 2 таких объекта для синхронизации доступа к размеру файла. Один из них -- paging IO resource -- захватывается эксклюзивно только в пути обрезания файла, и гарантирует, что в момент обрезания на файле нет активного ввода-вывода от кэша и от отображения в память.

8. Rundown protection. Полудокументированный (вызовы присутствуют в файлах-заголовках, но отсутствуют в документации) объект в ядре Windows. Счетчик с операциями «увеличить», «уменьшить» и «ждать». Ожидание блокирует поток до тех пор, пока операции уменьшения не уменьшат счетчик до нуля. Кроме того, операция увеличения может отказать, и наличие активного в данный момент времени ожидания заставляет отказывать все операции увеличения.



2.2 Реализация потоков в Delphi

язык программирование операционный поточность

Особенности реализации потоков Windows:

· любой поток, созданный в любом процессе, управляется напрямую планировщиком ядра операционной системы;

· реализована вытесняющая многозадачность (preemptive multitasking), то есть поток с более высоким приоритетом может вытеснить текущий поток;

· все потоки ядра выполняются либо в контексте потока, инициировавшего системный вызов - IO операцию, либо в контексте потока системного процесса system.

Потоки в Delphi.

Реализуются путем использования класса TThread:

1. Конструктор класса:

constructor Create(CreateSuspended: Boolean);

В качестве аргумента он получает параметр CreateSuspended. Если его значение равно True, вновь созданный поток не начинает выполняться до тех пор, пока не будет сделан вызов метода Resume. В случае, если CreateSuspended имеет значение False, поток начинает исполнение и конструктор.

2. Деструктор класса:

Destroy(destructor Destroy; override;) вызывается, когда необходимость в созданном потоке отпадает. Деструктор завершает его и высвобождает все ресурсы, связанные с объектом TThread.

Методы и свойства класса TThread:

· Resume вызывается, когда поток возобновляется после остановки, или если он был создан с параметром CreateSuspended равным True.

Пример: procedure Resume;

· Suspend приостанавливает поток с возможностью повторного запуска впоследствии. Метод Suspend приостанавливает поток вне зависимости от кода, исполняемого потоком в данный момент; выполнение продолжается с точки останова.

Пример: procedure Suspend;

· Suspended позволяет программисту определить, не приостановлен ли поток. С помощью этого свойства можно также запускать и останавливать поток. Установив suspended в True, вы получите тот же результат, что и при вызове метода Suspend -- приостановку. Наоборот, установка Suspended в False возобновляет выполнение потока, как и вызов метода Resume.

Пример: property Suspended: Boolean;

· Terminate; он останавливает(без последующего запуска) поток и возвращает управление вызвавшему процессу только после того, как это произошло. Значение, возвращаемое функцией Terminate, соответствует состоянию потока. Примерами возможных состояний являются случай нормального завершения и случай, когда к моменту вызова Terminate поток уже завершился (или был завершен из другого потока).

Пример: function Terminate: Integer;

· Terminate автоматически вызывается и из деструктора объекта TThread. В явном виде его, за редким исключением, вызывать не надо.Свойство Terminated позволяет узнать, произошел ли уже вызов метода Terminate ИЛИ нет.

Пример: property Terminated: Boolean;

· Метод WaitFor предназначен для синхронизации и позволяет одному потоку дождаться момента, когда завершится другой поток.

Пример: function WaitFor: Integer;

· Если внутри потока под именем FirstThread есть код:

Code := SecondThread.WaitFor;

то это означает, что поток FirstThread останавливается до момента завершения потока SecondThread. Метод WaitFor возвращает код завершения ожидаемого потока.

· Свойства Handle и ThreadID дают программисту непосредственный доступ к потоку средствами API. Если разработчик хочет обратиться к потоку и управлять им, минуя возможности класса TThread, значения Handle и ThreadID могут быть использованы в качестве аргументов функций API:

Пример: Property Handle: THandle read FHandle;

Пример: Property ThreadID: THandle read FThreadID;

· Свойство Priority позволяет запросить и установить приоритет потоков. Приоритет определяет, насколько часто поток получает время процессора.

Пример: property Priority: TThreadPriority;

Допустимыми значениями приоритета являются :

o tpIdle,

o tpLowest,

o tpLower,

o tpNormal,

o tpHigher,

o tpHighest

o tpTimeCritical.

· Synchronize предназначен для безопасного вызова методов VCL внутри потоков. Во избежание ситуаций гонок, метод Synchronize дает гарантию, что к каждому объекту VCL одновременно имеет доступ только один поток.

Аргумент, передаваемый в метод Synchronize, -- это имя метода, который производит обращение к VCL; вызов Synchronize с этим параметром -- это то же, что и вызов самого метода. Такой метод (класса TThreadMethod) не должен иметь никаких параметров и не должен возвращать никаких значений.

Пример: procedure Synchronize(Method: TThreadMethod);

· Execute: в его теле должен содержаться код, который и представляет собой собственно поток. Переопределяя метод Execute, мы можем тем самым закладывать в новый потоковый класс то, что будет выполняться при его запуске. Если поток был создан с аргументом СreateSuspended, равным False, то метод Execute выполняется немедленно, в противном случае Execute выполняется после вызова метода Resume.

Пример: procedure Execute;

· Свойство ReturnValue позволяет узнать и установить значение, возвращаемое потоком при его завершении. Эта величина полностью определяется пользователем. По умолчанию поток возвращает ноль, но если программист захочет вернуть другую величину, то простая переустановка свойства Returnvalue внутри потока позволит получить эту информацию другим потокам. Это, к примеру, может пригодиться, если внутри потока возникли проблемы, или с помощью ReturnValue нужно вернуть число не прошедших орфографическую проверку слов.

Пример: Property ReturnValue: Integer;

2.3 Программа, реализующая пример многопоточного приложения

В ходе выполнения программы используем тип многопоточности N:1 (Потоки выполнения уровня пользователя) предполагается, что все потоки выполнения уровня пользователя отображаются на единую планируемую сущность уровня ядра, и ядро ничего не знает о составе прикладных потоков выполнения. мы создаем 2 потока при нажатии на кнопку “Start Thread” мы запускаем 1 поток в котором выполняется вывод сообщение в соответствующую область и передаем управление в 2 поток который также выводит сообщение и останавливается.

Внешне программа имеет следующий интерфейс:

При выполнении:



Заключение

В ходе курсового проекта были рассмотрены основные элементы, проблемы и методы работы с потоками. Также была написана программа в которой была реализована Многопоточность.



Список литературы

1. Фаронов В. В. “DELPHI, Программирование на языке высокого уровня. Учебник для вузов ”, СПБ.: Питер, 2007. - 640 с.

2. Алексеев Е.Р., Чеснакова О.В. “Турбо Паскаль 7.0”, НТ Пресс, 2006г, 320с.

3. Культин Н.Б., “Основы программирования в Turbo Delphi”, СПБ.: БХВ - Петербург 2007. 320с.

4. Гордеев А. В. Операционные системы: Учебник для вузов. -- 2-е изд. -- СПб.: Питер, 2007. -- 416 с.

5. Олифер В. Г., Олифер Н. А. Сетевые операционные системы. -- СПб.: Питер, 2002. -- 544 с.

6. Воеводин В. В., Воеводин Вл. В. Параллельные вычисления. -- СПб: БХВ-Петербург, 2002. -- 608 с

7. Э.Таненбаум, А.Вудхалл. «Операционные системы: Разработка и реализация.» -- СПб.: 2006.

8. Першиков В. И., Савинков В. М. Толковый словарь по информатике / Рецензенты: канд. физ.-мат. наук А. С. Марков и д-р физ.-мат. наук И. В. Поттосин. -- М.: Финансы и статистика, 1991. -- 543 с.

9. Таненбаум Э. С. Многоуровневая организация ЭВМ = Structured Computer Organization. -- М.: Мир, 1979. -- 547 с

10. Иртегов Д. В. Введение в операционные системы. -- 2-е изд. -- СПб.: БХВ -СПб, 2007.



Приложение

1. Основная структура программы.

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, ExtCtrls, StdCtrls, ComCtrls, XPMan, SYNCOBJS, Unit2, Unit3;

type

TForm1 = class(TForm)

Panel1: TPanel;

Button1: TButton;

Edit1: TEdit;

Edit2: TEdit;

Label1: TLabel;

Label2: TLabel;

RichEdit1: TRichEdit;

XPManifest1: TXPManifest;

OpenDialog1: TOpenDialog;

procedure Button2Click(Sender: TObject);

procedure Button1Click(Sender: TObject);

private

{ Private declarations }

public

Thr1 : Thread1;

Thr2 : Thread2;

end;

var

Form1: TForm1;

Event : TEvent;

implementation

{$R *.dfm}

procedure TForm1.Button2Click(Sender: TObject);

begin

if OpenDialog1.Execute then

begin

RichEdit1.Lines.LoadFromFile(OpenDialog1.FileName);

end;

end;

procedure TForm1.Button1Click(Sender: TObject);

begin

Event := TEvent.Create(nil, false, true, '');

Thr1 := Thread1.Create(False);

Thr2 := Thread2.Create(False);

end;

end.

2. Поток № 1:

unit Unit2;

interface

uses

Classes, SYNCOBJS, windows;

type

Thread1 = class(TThread)

private

{ Private declarations }

protected

procedure Execute; override;

end;

implementation

uses MaskUtils,Unit1, SysUtils;

procedure Thread1.Execute;

begin

Event.WaitFor(infinite);

sleep(1000);

Form1.RichEdit1.Lines.Add('Welcome to Hell!!!');

Form1.Edit1.text :='Done';

Event.SetEvent;

end;

end.

3. Поток № 2:

unit Unit3;

interface

uses

Classes, SYNCOBJS, windows;

type

Thread2 = class(TThread)

private

{ Private declarations }

protected

procedure Execute; override;

end;

implementation

uses unit1, sysUtils;

procedure Thread2.Execute;

begin

Event.WaitFor(infinite);

Sleep(1000);

Form1.RichEdit1.Lines.Add('And goodbye!!!');

Form1.Edit2.text :='Done';

Event.SetEvent;

end;

end.

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