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

Подсистема управления процессами и потоками ответственна за обеспечение процессов необходимыми ресурсами.

• ОС поддерживает в памяти специальные ин­формационные структуры , в которые записывает, какие ресурсы выделены каж­дому процессу.
• ОС может назначить процессу ресурсы в единоличное пользо­вание или в совместное пользование с другими процессами.
• Некоторые из ресур­сов выделяются процессу при его создании, а некоторые - динамически по за­просам во время выполнения. Ресурсы могут быть приписаны процессу на все время его жизни или только на определенный период.
• При выполнении основных функций подсистема управления процессами взаимодействует с другими подсис­темами ОС, ответственными за управление ресурсами, такими как подсистема управления памятью, подсистема ввода-вывода, файловая система.
• Синхронизацияпотоков является одной из важных функций подсистемы управления процессами и потоками. Хотя потоки возникают и выполняются асинхронно, у них может возникнуть необходимость во взаимодействии, напри­мер при обмене данными. Согласование скоростей потоков также очень важно для предотвращения эффекта «гонок» (когда несколько потоков пытаются изме­нить один и тот же файл), взаимных блокировок или других коллизий, которые возникают при совместном использовании ресурсов.
• По завершении процесса подсистема управления процессами за­крывает все файлы, с которыми работал процесс, освобождает области опера­тивной памяти, отведенные под коды, данные и системные информационные структуры процесса. Выполняется коррекция всевозможных очередей ОС и спи­сков ресурсов, в которых имелись ссылки на завершаемый процесс.

Понятия «процесс» и «поток»

Единицы работы ОС

В настоящее время в большинстве ОС определены два типа единиц работы. Более крупная еди­ница работы, обычно носящая название процесса, или задачи, требует для своего выполнения нескольких более мелких работ, для обозначения которых исполь­зуют термины «поток», или «нить».

И с процессом, и с потоком связывается оп­ределенный программный код, который для этих целей оформляется в виде ис­полняемого модуля. Чтобы этот программный код мог быть выполнен, его необ­ходимо загрузить в оперативную память, возможно, выделить некоторое место на диске для хранения данных, предоставить доступ к устройствам ввода-выво­да, например к последовательному порту для получения данных по подключен­ному к этому порту модему, и т. д. В ходе выполнения программе может также понадобиться доступ к информационным ресурсам, например файлам, портам TCP/UPD. И, конечно же, невозможно выполнение программы без предоставления ей процессорного времени, то есть времени, в течение которого процессор выполняет коды данной программы.

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

В простейшем случае процесс состоит из одного потока, в таких системах понятие «поток» полностью поглощается понятием «процесс», то есть остается только одна единица работы и потребления ресур­сов - процесс. Мультипрограммирование осуществляется в таких ОС на уровне процессов.

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

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

Подсистема управления процессами.

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

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

Основные функции подсистемы управления процессами:

1) распределение процессорного времени между несколькими одновременно существующими в системе процессами;

2) создание и уничтожение процессов;

3) обеспечение процессов необходимыми системными ресурсами;

4) поддержка взаимодействия между процессами.

Обычно процесс представляется как совокупность двух следующих компонентов:

1) объект ядра, через который операционная система управляет процессом, и где хранится статистическая информация о процессе;

2) адресное пространство, в котором содержится код и данные всех модулей процесса.

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

При создании процесса первый или первичный поток обычно создается системой автоматически.

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

Состояния процесса (потока).

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

1) выполнение - активное состояние процесса, во время которого процесс обладает всеми необходимыми ресурсами и непосредственно выполняется процессором;

2) ожидание - пассивное состояние процесса, процесс заблокирован и ждет осуществления некоторого события (например, завершения операции ввода-вывода, получения сообщения от другого процесса, освобождения какого-либо необходимого ему ресурса);

3) готовность - пассивное состояние процесса, при котором процесс блокируется в связи с внешними по отношению к нему обстоятельствами: т.е. процесс имеет все требуемые для него ресурсы, он готов выполняться, однако процессор занят выполнением другого процесса.

В ходе жизненного цикла каждый процесс переходит из одного состояния в другое в соответствии с алгоритмом планирования процессов, реализуемым в данной операционной системе.

Контекст и дескриптор процесса (потока).

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

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

Планирование и диспетчеризация потоков.

На протяжении существования процесса выполнение его потоков может быть многократно прервано и продолжено.

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

Планирование потоков, по существу, включает в себя решение двух задач:

1 - определение момента времени для смены текущего активного потока;

2 - выбор для выполнения потока из очереди готовых потоков.

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

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

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

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

Диспетчеризация сводится к следующему:

Сохранение контекста текущего потока, который требуется сменить;

Запуск нового потока на выполнение.

Вытесняющие и невытесняющие алгоритмы планирования.

Вытесняющие (preemptive) алгоритмы — это такие способы планирования потоков, в которых решение о переключении процессора с выполнения одного потока на выполнение другого потока принимается операционной системой, а не активной задачей.

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

Достоинство: высокая надёжность системы в целом.

Недостаток: снижение производительности за счёт траты процессорного времени на переключение задач.

Невытесняющие (поп-preemptive) алгоритмы основаны на том, что активному потоку позволяется выполняться, пока он сам, по собственной инициативе, не отдаст управление операционной системе для того, чтобы та выбрала из очереди другой готовый к выполнению поток.

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

Достоинство: высокая производительность, более высокая скорость переключения с потока на поток.

Недостаток: низкая надёжность, сложность разработки пользовательских приложений.

Алгоритмы планирования, основанные на приоритетах.

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

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

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

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

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

В системах с абсолютными приоритетами выполнение активного потока прерывается кроме указанных выше причин, еще при одном условии: если в очереди готовых потоков появился поток, приоритет которого выше приоритета активного потока.

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

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

Алгоритмы планирования, основанные на квантовании.

В основе многих вытесняющих алгоритмов планирования лежит концепция квантования. В соответствии с этой концепцией каждому потоку поочередно для выполнения предоставляется ограниченный непрерывный период процессорного времени — квант.

Смена активного потока происходит, если:

1 - поток завершился и покинул систему;

2 - произошла ошибка;

3 - поток перешел в состояние ожидания;

4 - исчерпан квант процессорного времени, отведенный данному потоку.

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

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

Если квант короткий, то суммарное время, которое проводит поток в ожидании процессора, прямо пропорционально времени, требуемому для его выполнения (то есть времени, которое потребовалось бы для выполнения этого потока при монопольном использовании вычислительной системы).

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

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

Министерство транспорта РФ

Федеральное агентство железнодорожного транспорта

ГОУ ВПО "ДВГУПС"

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

на тему: "Подсистема управления процессами"

Выполнил: Шолков И.Д.

группа 230

Проверил: Решетникова О.В.

Хабаровск 2010

Введение

1. Описание программы

1.1 Функциональное назначение

1.2 Технические средства, используемые при создании программы

1.3 Многопоточность и многопроцессорность

1.4 Приоритеты потоков и процессов

1.5 Способы синхронизации потоков

1.3 Логическая структура программы

2. Руководство пользователя по работе с программой

2.1 Общие сведения и назначение программы

2.2 Графический интерфейс

2.3 Работа с программой

2.4 Основные характеристики программы ProcessManager

Заключение

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

C# поддерживает параллельное выполнение кода через многопоточность. Поток – это независимый путь исполнения, способный выполняться одновременно с другими потоками.

Программа на C# запускается как единственный поток, автоматически создаваемый CLR и операционной системой ("главный" поток), и становится многопоточной при помощи создания дополнительных потоков.

Управление многопоточностью осуществляет планировщик потоков, эту функцию CLR обычно делегирует операционной системе. Планировщик потоков гарантирует, что активным потокам выделяется соответствующее время на выполнение, а потоки, ожидающие или блокированные, к примеру, на ожидании эксклюзивной блокировки, или пользовательского ввода – не потребляют времени CPU.

На однопроцессорных компьютерах планировщик потоков использует квантование времени – быстрое переключение между выполнением каждого из активных потоков. Это приводит к непредсказуемому поведению, как в самом первом примере, где каждая последовательность символов ‘X’ и ‘Y’ соответствует кванту времени, выделенному потоку. В Windows XP типичное значение кванта времени – десятки миллисекунд – выбрано как намного большее, чем затраты CPU на переключение контекста между потоками (несколько микросекунд).

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

Говорят, что поток вытесняется, когда его выполнение приостанавливается из-за внешних факторов типа квантования времени. В большинстве случаев поток не может контролировать, когда и где он будет вытеснен.

Все потоки одного приложения логически содержатся в пределах процесса – модуля операционной системы, в котором исполняется приложение.

В некоторых аспектах потоки и процессы схожи – например, время разделяется между процессами, исполняющимися на одном компьютере, так же, как между потоками одного C#-приложения. Ключевое различие состоит в том, что процессы полностью изолированы друг от друга. Потоки разделяют память (кучу) с другими потоками этого же приложения. Благодаря этому один поток может поставлять данные в фоновом режиме, а другой – показывать эти данные по мере их поступления.

Свойство Priority определяет, сколько времени на исполнение будет выделено потоку относительно других потоков того же процесса. Существует 5 градацийприоритетапотока:enum ThreadPriority { Lowest, BelowNormal, Normal, AboveNormal, Highest }

Значение приоритета становится существенным, когда одновременно исполняются несколько потоков.

Установка приоритета потока на максимум еще не означает работу в реальном времени (real-time), так как существуют еще приоритет процесса приложения. Чтобы работать в реальном времени, нужно использовать класс Process из пространства имен System.Diagnostics для поднятия приоритета процесса.

От ProcessPriorityClass.High один шаг до наивысшего приоритета процесса – Realtime. Устанавливая приоритет процесса в Realtime, вы говорите операционной системе, что хотите, чтобы ваш процесс никогда не вытеснялся. Если ваша программа случайно попадет в бесконечный цикл, операционная система может быть полностью заблокирована. Спасти вас в этом случае сможет только кнопка выключения питания. По этой причине ProcessPriorityClass.High считается максимальным приоритетом процесса, пригодным к употреблению.

Если real-time приложение имеет пользовательский интерфейс, может быть не желательно поднимать приоритет его процесса, так как обновление экрана будет съедать чересчур много времени CPU – тормозя весь компьютер, особенно если UI достаточно сложный.

Оператор lock (aka Monitor.Enter/Monitor.Exit) – один из примеров конструкций синхронизации потоков. Lock является самым подходящим средством для организации монопольного доступа к ресурсу или секции кода, но есть задачи синхронизации (типа подачи сигнала начала работы ожидающему потоку), для которых lock будет не самым адекватным и удобным средством.

В Win32 API имеется богатый набор конструкций синхронизации, и они доступны в.NET Framework в виде классов EventWaitHandle, Mutex и Semaphore. Некоторые из них практичнее других: Mutex, например, по большей части дублирует возможности lock, в то время как EventWaitHandle предоставляет уникальные возможности сигнализации.

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

EventWaitHandle имеет два производных класса – AutoResetEvent и ManualResetEvent (не имеющие никакого отношения к событиям и делегатам C#). Обоим классам доступны все функциональные возможности базового класса, единственное отличие состоит в вызове конструктора базового класса с разными параметрами.

В части производительности, все WaitHandle обычно исполняются в районе нескольких микросекунд. Это редко имеет значение с учетом контекста, в котором они применяются.

AutoResetEvent – наиболее часто используемый WaitHandle-класс и основная конструкция синхронизации, наряду с lock.

AutoResetEvent очень похож на турникет – один билет позволяет пройти одному человеку. Приставка "auto" в названии относится к тому факту, что открытый турникет автоматически закрывается или "сбрасывается" после того, как позволяет кому-нибудь пройти. Поток блокируется у турникета вызовом WaitOne (ждать (wait) у данного (one) турникета, пока он не откроется), а билет вставляется вызовом метода Set. Если несколько потоков вызывают WaitOne, за турникетом образуется очередь. Билет может "вставить" любой поток – другими словами, любой (неблокированный) поток, имеющий доступ к объекту AutoResetEvent, может вызвать Set, чтобы пропустить один блокированный поток.

Если Set вызывается, когда нет ожидающих потоков, хэндл будет находиться в открытом состоянии, пока какой-нибудь поток не вызовет WaitOne. Эта особенность помогает избежать гонок между потоком, подходящим к турникету, и потоком, вставляющим билет ("опа, билет вставлен на микросекунду раньше, очень жаль, но вам придется подождать еще сколько-нибудь!"). Однако многократный вызов Set для свободного турникета не разрешает пропустить за раз целую толпу – сможет пройти только один человек, все остальные билеты будут потрачены впустую.

WaitOne принимает необязательный параметр timeout – метод возвращает false, если ожидание заканчивается по таймауту, а не по получению сигнала. WaitOne также можно обучить выходить из текущего контекста синхронизации для продолжения ожидания (если используется режим с автоматической блокировкой) во избежание чрезмерного блокирования.

Метод Reset обеспечивает закрытие открытого турникета, безо всяких ожиданий и блокировок.

AutoResetEvent может быть создан двумя путями. Во-первых, с помощью своего конструктора:EventWaitHandle wh = new AutoResetEvent(false);

Если аргумент конструктора true, метод Set будет вызван автоматически сразу после создания объекта.

Другой метод состоит в создании объекта базового класса, EventWaitHandle:EventWaitHandle wh = new EventWaitHandle(false, EventResetMode.Auto);

Конструктор EventWaitHandle также может использоваться для создания объекта ManualResetEvent (если задать в качестве параметра EventResetMode.Manual).

Метод Close нужно вызывать сразу же, как только WaitHandle станет не нужен – для освобождения ресурсов операционной системы. Однако если WaitHandle используется на протяжении всей жизни приложения (как в большинстве примеров этого раздела), этот шаг можно опустить, так как он будет выполнен автоматически при разрушении домена приложения.

ManualResetEvent – это разновидность AutoResetEvent. Отличие состоит в том, что он не сбрасывается автоматически, после того как поток проходит через WaitOne, и действует как шлагбаум – Set открывает его, позволяя пройти любому количеству потоков, вызвавших WaitOne. Reset закрывает шлагбаум, потенциально накапливая очередь ожидающих следующего открытия.

Эту функциональность можно эмулировать при помощи булевой переменной "gateOpen" (объявленной как volatile) в комбинации со "spin-sleeping" – повторением проверок флага и ожидания в течении короткого промежутка времени.

ManualResetEvent может использоваться для сигнализации о завершении какой-либо операции или инициализации потока и готовности к выполнению работы.

1.3 Логическая структура программы

Основу программы составляет абстрактный класс Betaproc. В нем реализована абстрактная модель процесса, без спецификации выполняемых действий, с набором переменных и методов общих для всех процессов. Три процесса sinProc, FibbonProc и ProcRandom являются производными от этого класса и в каждом из них реализован лишь методы возвращающие тип процесса и сам метод выполняемый процессом. При этом каждый метод Base, в котором находится исполняемый код, имеет в своем теле общий для всех хэндл, который позволяет выполнять код лишь одному процессу, когда другие становятся в очередь и получают свое время на выполнение пропорционально приоритету. В момент начала работы стартует таймер, который обеспечивает одинаковый квант времени в 3 секунды для каждого процесса.

Однако процессы не висят в памяти компьютера просто так. Специально для управления процессами создан класс ProcManager. При создании процесса он и вся информация о нем заносится в массив, и в соответствии с номером ячейки, в которую записывается процесс, ему дается идентификатор, по которому к нему можно обратиться в процессе работы. Также в классе ProcManager реализовано графическое представление в памяти. Каждый важный элемент процесса выведен в специальную таблицу на форме, и при изменении одного из них вызывается событие, которое меняет запись в таблице в режиме реального времени, поэтому мы может наблюдать как красиво надпись "работает" бегает от одного процесса к другому.

2. Руководство пользователя по работе с программой

2.1 Общие сведения и назначение программы

Программа написана в среде VisualStudio 2008 на языке C# и представляет собой менеджер управления процессами, построенный на современных средствах управления, с интуитивно понятным графическим интерфейсом. Программа является полностью автономной и не требует установки другого программного обеспечения. Вся справочная информация хранится в настоящем Руководстве и Техническом Проекте. В случае сбоев в работе программы необходимо обратиться к Автору для их устранения. В основной части руководства будут описаны возможности программы, описание основных характеристик и особенностей программы.

2.2 Графический интерфейс

После открытия программы пользователю предоставляется графический интерфейс.

рис 1.: главное окно программы после запуска

Область "Процесс" позволяет выбрать тот процесс, который нам необходимо запустить. Имеет три пункта: Числа Фибоначчи, Случайные числа и Рекурсивный синус.

Область "Приоритет" позволяет установить приоритет запускаемому процессу. Имеет 5 пунктов: Низкий, Ниже среднего, Средний, Выше среднего, Высокий.

Кнопка запуск служит для запуска процесса с выбранными параметрами.

Таблица в центральной части окна отображает состояние каждого из запущенных процессов. После добавления каждого процесса в нее автоматически добавляется одна строка. Имеет 5 полей:

1) Номер процесса – показывает порядковый номер процесса

2) Тип процесса – показывает действие, с которое выполняет данный процесс

3) Состояние процесса – показывает работает ли процесс в данный момент или нет. Также показывает, если процесс является остановленным, завершенным или только что возобновленным.

4) Приоритет процесса – показывает приоритет процесса, который был присвоен ему при создании.

5) Процент процессорного времени – отображает процент используемого процессорного времени.

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

В нижней части окна программы расположены элементы управления для работы с уже запущенными процессами.

Кнопка "Остановить" - останавливает выбранный процесс с возможностью его последующего перезапуска.

Кнопка "Возобновить" - вновь запускает остановленный процесс.

Кнопка "Завершить" - останавливает выбранный процесс без возможности его завершения.

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

2.3 Работа с программой

Запуск процессов выполняется с помощью кнопки "Запустить", однако перед этим следует установить параметры процесса.

Случайное число – процесс генерирует случайное число в интервале от одного до ста и выводит его в поле вывода.

Числа Фибоначчи – генерирует последовательность Фибоначчи, начиная с первого члена, и выводит их в поле вывода. Как только значение чисел последовательности превосходит тысячу – значения сбрасываются до первых членов.

Рекурсивный синус – генерирует значение синуса X. Первоначально X равен 1, позже ему присваиваются посчитанные значения sin(x). Значения, округленные до третьего знака выводятся в поле вывода.

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

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

рис 2: работа программы.

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

Если нам хочется остановить процесс под номером 2, необходимо выбрать вторую строку в таблице процессов и нажать кнопку "Остановить". После выполнения команды окно примет следующий вид:

рис. 3: процесс с Process ID = 2 остановлен.

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

Процесс, который вновь начал работу, но еще ни разу не выполнялся отмечается подписью "Возобновлен" в третьем столбце, как на картинке:

рис. 4: работа процесса с Process ID = 2 возобновлена.

Если мы захотим завершить процесс, под номером 3, необходимо выбрать третью строку в таблице процессов и нажать кнопку "Завершить". Процесс, который завершен уже не может быть запущен вновь. Создайте процесс с такими же параметрами.

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

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

2.4 Основные характеристики программы Process Manager

ProcessManager – это программа, предназначенная для управления процессами пользователем персонального компьютера. Она работает под управлением операционных систем MS Windows 2000/XP/Vista/7.

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

Программа включает в себя набор базовых элементов, каждый из которых позволяет выполнить определенную задачу проекта. После загрузки проекта и запуска процессов значения и параметры работы процессов сразу отображаются на дисплее. Подробное описание работы с программой представлено в первом пункте настоящего документа. Подробное описание логической структуры программы и код программы можно найти в документе "Технический проект автоматизированной подсистемы для визуализации работы с процессами ProcessManager". Программа работает в штатном режиме, однако в случае необходимости может работать круглосуточно и непрерывно. Программа прошла всестороннюю проверку и полностью защищена от сбоев и исключений.

Заключение

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

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

1) Безбогов, А.А. Безопасность операционных систем: учебное пособие / А.А. Безбогов, А.В. Яковлев, Ю.Ф. Мартемьянов. – М. : "Издательство Машиностроение-1", 2007. – 220 с.

2) Операционные системы, лекции по операционным системам [Электронный ресурс] / www.osi-ru.ru. - Содержание: Управление процессами; Управление памятью; Управление данными; Управление устройствами

3) Троелсен, Э. C# и платформа.NET: учебное пособие/ Э.Троелсен. – Спб. : "Питер Пресс", 2007. –796с.

Приложение

Исходный код программы ProcessManager

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading;

using System.Windows.Forms;

using Timer=System.Threading.Timer;

namespace ProcManager

abstract class BetaProc

protected Thread a;

bool isWorking = false;

public event EventHandler WorkingStateChanged = delegate { };

public bool IsWorking

get { return isWorking; }

isWorking = value;

WorkingStateChanged(this, EventArgs.Empty);

public void Delete()

if (IsWorking == true)

if (WaitToStart.Set() == false)

WaitToStart.Set();

public ThreadPriority Prior

get { return a.Priority; }

set { a.Priority = value; }

public void Stop()

if(isWorking == true)

WaitToStart.Set();

private DataGridView data;

public delegate void ChangeStateEventHandler(string msg);

public static event ChangeStateEventHandler change;

public abstract string GetType();

public string GetState()

return IsWorking ? "Работает" : "Не работает";

public string GetPriority()

return a.Priority.ToString();

public void ChangeState()

if (IsWorking == false)

IsWorking = true;

IsWorking = false;

public abstract void Base();

private Control pReporter;

public DataGridView reporterD

public Control reporter

return pReporter;

pReporter = value;

public EventWaitHandle SwaitTostart

WaitToStart = value;

protected Stopwatch timer = new Stopwatch();

public void Start()

a = new Thread(Base);

delegate void SetTextDelegate2(string Text);

public static EventWaitHandle WaitToStart;

public void SetText2(string Text)

if (reporter.InvokeRequired)

SetTextDelegate2 a = new SetTextDelegate2(SetText2);

reporter.Invoke(a, new object { Text });

else reporter.Text += Text;

public void Restart()

if(isWorking == true)

timer = new Stopwatch();

a=new Thread(Base);

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading;

namespace ProcManager

class FibbonProc:BetaProc

public readonly string Type = "ЧислаФиббоначи";

private int FSum = 1;

private int FSum2 = 1;

private int temp = 0;

public override void Base()

WaitToStart.WaitOne();

if (IsWorking == false)

if (FSum >= 1000)

FSum = FSum + FSum2;

SetText2(FSum.ToString() + "\r\n");

Thread.Sleep(1110);

<= 3000);

WaitToStart.Set();

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading;

namespace ProcManager

class ProcRandom:BetaProc

Random a = new Random();

private int res;

public readonly string Type = "Случайноечисло";

public override string GetType()

public override void Base()

WaitToStart.WaitOne();

if (IsWorking == false)

res = a.Next(100);

SetText2(res.ToString()+"\r\n");

Thread.Sleep(1110);

while (timer.ElapsedMilliseconds <= 3000);

WaitToStart.Set();

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading;

namespace ProcManager

class SinProc:BetaProc

private double x = 1;

public readonly string Type = "Синус X";

public override string GetType()

public override void Base()

WaitToStart.WaitOne();

if(IsWorking == false)

x = Math.Sin(x);

SetText2(Math.Round(x, 3).ToString()+"\r\n");

Thread.Sleep(1110);

while (timer.ElapsedMilliseconds <= 3000);

WaitToStart.Set();

using System.Collections;

using System.Threading;

using System.Windows.Forms;

namespace ProcManager

class ClassProcManager

private BetaProc mas = new BetaProc;

private DataGridView a;

private int index = 0;

public BetaProc ReturnMas()

public int Index()

public DataGridView reporterD

public void AddThread(BetaProc a)

if (index < mas.Length)

MessageBox.Show("Слишком много процессов");

public void ShowInDataView(BetaProc b)

a.Rows.Add(index + 1, b.GetType(), b.GetState(), b.GetPriority());

public void SetWaitProperty(BetaProc b)

int i = Array.IndexOf(mas, b);

if((i<0) || (i>a.Rows.Count - 1))

for (int s = 0; s < index; s++)

if ((int)a.Rows[s].Cells.Value == i+1)

DataGridViewRow row = a.Rows[s];

row.Cells.Value = b.GetState();

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Diagnostics;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading;

using System.Windows.Forms;

namespace ProcManager

public partial class Form1: Form

InitializeComponent();

public int index = 0;

private ClassProcManager manager = new ClassProcManager();

private EventWaitHandle wh1 = new AutoResetEvent(true);

private RadioGroup processType;

private RadioGroup processPriority;

private ThreadPriority ProcessPriorities = new ThreadPriority;

ThreadPriority HighestPriority = ThreadPriority.Lowest;

///

/// Возвращаетприоритетпроцесса

///

/// Tag

/// Объектизперечисления ThreadPriority

private ThreadPriority IndexToPriority(int priority)

switch (priority)

case 0: return ThreadPriority.Lowest;

case 1: return ThreadPriority.BelowNormal;

case 2: return ThreadPriority.Normal;

case 3: return ThreadPriority.AboveNormal;

case 4: return ThreadPriority.Highest;

default: return ThreadPriority.Normal;

private void button1_Click(object sender, EventArgs e)

BetaProc process;

switch (processType.SelectedButton)

case 0: process = new FibbonProc();

case 1: process = new ProcRandom();

case 2: process = new SinProc();

default: process = new ProcRandom();

process.SwaitTostart = wh1;

process.reporter = richTextBox1;

process.reporterD = dataGridView1;

process.Start();

process.Prior = IndexToPriority(processPriority.SelectedButton);

manager.AddThread(process);

manager.ShowInDataView(process);

process.WorkingStateChanged += new EventHandler(a_WorkingStateChanged);

// расчётпроцессорноноговремени

if (process.Prior > HighestPriority) HighestPriority = process.Prior;

ProcessPriorities = process.Prior;

if (index >= 1)

double FreeProcessorTime = 100;

double TimePerProcess = 100 / (index + 1);

double PriorityWeight = 0;

int HighPriorityProcessCount = 0;

// расчётдляпроцессовсприоритетомнижесамогобольшого

for (int i = 0; i < index + 1; i++)

if (ProcessPriorities[i] != HighestPriority)

switch (ProcessPriorities[i])

case ThreadPriority.Lowest: PriorityWeight = 0.2;

case ThreadPriority.BelowNormal: PriorityWeight = 0.4;

case ThreadPriority.Normal: PriorityWeight = 0.6;

case ThreadPriority.AboveNormal: PriorityWeight = 0.8;

FreeProcessorTime -= TimePerProcess * PriorityWeight;

dataGridView1.Rows[i].Cells.Value = Math.Round(TimePerProcess * PriorityWeight);

else HighPriorityProcessCount++;

// расчёт для процессов с самым большим приоритетом

for (int i = 0; i < index + 1; i++)

if (ProcessPriorities[i] == HighestPriority)

dataGridView1.Rows[i].Cells.Value = Math.Round(FreeProcessorTime / HighPriorityProcessCount);

else dataGridView1.Rows.Cells.Value = "100";

void a_WorkingStateChanged(object sender, EventArgs e)

BetaProc b = sender as BetaProc;

manager.SetWaitProperty(b);

private void Form1_Load(object sender, EventArgs e)

manager.reporterD = dataGridView1;

// Заполняем RadioGroup processType и processPriority объектами RadioButton

RadioButton processTypeRadioButtons = new RadioButton;

for (int i = 0; i < groupBox1.Controls.Count; i++) processTypeRadioButtons[i] = (RadioButton)groupBox1.Controls[i];

RadioButton processPriorityRadioButtons = new RadioButton;

for (int i = 0; i < groupBox2.Controls.Count; i++) processPriorityRadioButtons[i] = (RadioButton)groupBox2.Controls[i];

processType = new RadioGroup(processTypeRadioButtons);

processPriority = new RadioGroup(processPriorityRadioButtons);

private void button2_Click(object sender, EventArgs e)

if (processID != -1 && (string)manager.reporterD.Rows.Cells.Value != "Завершен")

manager.ReturnMas().Stop();

manager.reporterD.Rows.Cells.Value = "Приостановлен";

private void button3_Click(object sender, EventArgs e)

int processID = (int)dataGridView1.SelectedRows.Cells.Value - 1;

if ((string)manager.reporterD.Rows.Cells.Value == "Приостановлен")

manager.ReturnMas().Restart();

manager.reporterD.Rows.Cells.Value = "Возобновлен";

private void button4_Click(object sender, EventArgs e)

int processID = (int)dataGridView1.SelectedRows.Cells.Value - 1;

if (processID != -1)

manager.ReturnMas().Delete();

manager.reporterD.Rows.Cells.Value = "Завершен";

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

создание процессов и потоков;

обеспечение процессов и потоков необходимыми ресурсами;

изоляция процессов ;

планирование выполнения процессов и потоков (вообще, следует говорить и о планировании заданий);

диспетчеризация потоков;

организация межпроцессного взаимодействия;

синхронизация процессов и потоков;

завершение и уничтожение процессов и потоков.

1. К созданию процесса приводят пять основных событий:

выполнение запроса работающего процесса на создание процесса;

запрос пользователя на создание процесса, например, при входе в систему в интерактивном режиме;

инициирование пакетного задания;

создание операционной системой процесса, необходимого для работы каких-либо служб.

Обычно при загрузке ОС создаются несколько процессов. Некоторые из них являются высокоприоритетными процессами, обеспечивающими взаимодействие с пользователями и выполняющими заданную работу. Остальные процессы являются фоновыми, они не связаны с конкретными пользователями, но выполняют особые функции – например, связанные с электронной почтой, Web-страницами, выводом на печать , передачей файлов по сети, периодическим запуском программ (например,дефрагментации дисков ) и т.д. Фоновые процессы называют демонами.

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

2. С технической точки зрения во всех перечисленных случаях новый процесс формируется одинаково: текущий процесс выполняет системный запрос на создание нового процесса. Подсистема управления процессами и потоками отвечает за обеспечение процессов необходимыми ресурсами . ОС поддерживает в памяти специальные информационные структуры, в которые записывает, какие ресурсы выделены каждому процессу. Она может назначить процессу ресурсы в единоличное пользование или совместное пользование с другими процессами. Некоторые из ресурсов выделяются процессу при его создании, а некоторые – динамическипо запросам во время выполнения . Ресурсы могут быть выделены процессу на все время его жизни или только на определенный период. При выполнении этих функций подсистема управления процессами взаимодействует с другими подсистемами ОС, ответственными за управление ресурсами , такими как подсистема управления памятью, подсистема ввода-вывода , файловая система .

3. Для того чтобы процессы не могли вмешаться в распределение ресурсов , а также не могли повредить коды и данные друг друга, важнейшей задачей ОС является изоляция одного процесса от другого . Для этого операционная система обеспечивает каждый процесс отдельным виртуальным адресным пространством, так что ни один процесс не может получить прямого доступа к командам и данным другого процесса.

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

5. Диспетчеризация заключается в реализации найденного в результате планирования решения, т.е. в переключении процессора с одного потока на другой. Диспетчеризация проходит в три этапа:

сохранение контекста текущего потока;

запуск нового потока на выполнение.

6. Когда в системе одновременно выполняется несколько независимых задач, возникают дополнительные проблемы. Хотя потоки возникают и выполняются синхронно, у них может возникнуть необходимость во взаимодействии , например, при обмене данными. Для общения друг с другом процессы и потоки могут использовать широкий спектр возможностей: каналы (в UNIX ), почтовые ящики (Windows ), вызов удаленной процедуры, сокеты (в Windows соединяют процессы на разных машинах). Согласование скоростей потоков также очень важно для предотвращения эффекта "гонок" (когда несколько потоков пытаются изменить один и тот же файл ), взаимных блокировок и других коллизий, которые возникают при совместном использовании ресурсов.

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

8. Каждый раз, когда процесс завершается , – а это происходит благодаря одному из следующих событий: обычный выход , выход по ошибке, выход по неисправимой ошибке, уничтожение другим процессом – ОС предпринимает шаги, чтобы "зачистить следы" его пребывания в системе. Подсистема управления процессами закрывает все файлы, с которыми работал процесс, освобождает области оперативной памяти, отведенные под коды, данные и системные информационные структуры процесса. Выполняется коррекция всевозможных очередей ОС и список ресурсов, в которых имелись ссылки на завершаемый процесс.

Запущенная на выполнение программа порождает в системе один или более процессов (или задач).

Подсистема управления процессами контролирует:

Создание и удаление процессов.

Распределение системных ресурсов (памяти, вычислительных ре­сурсов) между процессами.

Синхронизацию процессов.

Межпроцессорное взаимодействие.

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

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

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

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

Подсистема ввода/вывода.

Подсистема ввода/вывода выполняет запросы файловой под­системы и подсистемы управления процессами для доступа к ПУ (дискам, магнитным лентам, терминалам и т. д.). Она обеспечивает необходимую буферизацию данных и взаимодействует с драйверами устройств – специальными модулями ядра, непосредственно обслу­живающими внешние устройства.

Файловая система ос unix.

Понятие файла в ОС UNIX максимально унифицировано. Файлами считаются обычные файлы, каталоги, каналы; внешние устройства представляются в виде специальных файлов: байт-ориен­тированных (например терминал, принтер, последовательный порт) и блок-ориентированных (накопители на магнитных дисках) в зави­симости от единиц передаваемых данных.

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

Такой подход обеспечивает независимость программы пользо­вателя от особенностей ввода-вывода на конкретное устройство. Помимо этого, файлы в UNIX определяют привилегии пользовате­лей, поскольку права пользователя контролируются с помощью прав доступа к файлам.

Как и во многих ОС-ах, в UNIX файлы организованы в виде древовидной структуры, называемой файловой системой. Корнем этого дерева является корневой каталог , имеющий имя «/». Имена всех остальных файлов содержат путь – список каталогов (ветвей), которые необходимо пройти, чтобы достичь файла. Таким образом, полное имя любого файла начинается с «/» и не содержит идентифи­катора устройства, на котором он фактически хранится. UNIX до­пускает существование нескольких файловых систем, присоединен­ных к корневому каталогу.

В UNIX существует 6 типов файлов, различающихся по функ­циональному назначению и действиям операционной системы при выполнении операций над файлами.

Обычный файл (regular file).

Каталог (directory).

Специальный файл устройства (special device file).

FIFO или именованный канал (named pipe).

Связь (link).

Обычный файл представляет собой наиболее общий тип фай­лов, содержащий данные в некотором формате. Для ОС такие файлы представляют собой просто последовательность байтов. Эти файлы обрабатываются прикладной программой.

Каталог – это файл, содержащий имена находящихся в нем файлов, а также указатели на дополнительную информацию – мета­данные, позволяющие ОС производить операции над этими фай­лами. Каталоги определяют положение файла в дереве файловой системы, поскольку сам файл не содержит информации о своем ме­стонахождении. Любая программа может прочитать содержание ка­талога, но только ядро имеет право на запись в каталог.

По существу каталог представляет собой таблицу, каждая за­пись которой соответствует некоторому файлу.

10245 . - текущий каталог

12432 .. - родительский каталог

номер имя

метаданные файла

Специальный файл устройства обеспечивает доступ к физиче­скому устройству. В UNIX различают символьные (character) и блочные (block) файлы устройств. Доступ к устройствам осуществ­ляется путем открытия, чтения и записи в специальный файл уст­ройства.

Символьные файлы устройств используются для не буферизо­ванного обмена данными с устройством, в противоположность этому блочные файлы позволяют производить обмен данными в виде пакетов фиксированной длины – блоков. Доступ к некоторым устройствам может осуществляться как через символьные, так и че­рез блочные специальные файлы.

FIFO или именованный канал – это файл, используемый для связи между процессами. FIFO впервые появился в System V UNIX, и большинство современных систем поддерживают этот механизм.

Связь. Как уже отмечалось, каталог содержит имена файлов и указатели на их метаданные. В то же время сами метаданные не со­держат ни имени файла, ни указателя на его имя. Такая архитектура позволяет одному файлу иметь несколько имен в файловой системе. Имена тесно связаны с метаданными и, соответственно, с данными файла, в то время как файл существует независимо от того, как его называют. Такая связь имени файла с его данными называется жест­кой связью (hard link). Жесткая связь является естественной формой связи имени файла с его метаданными и не принадлежит к особому типу файла. Особым типом файла является символическая связь, по­зволяющая косвенно адресовать файл. Символическая связь адре­сует файл, который, в свою очередь, ссылается на другой файл. Дан­ные файла, являющиеся символической связью, содержат только имя целевого файла, и ОС работает с такими файлами не так, как с обычными.

Сокеты предназначены для взаимодействия между процес­сами. Интерфейс сокетов часто используется для доступа к сети TCP/IP. В системах, ветви BSDINIX на базе сокетов реализована система межпроцессорного взаимодействия, с помощью которой ра­ботают многие системные сервисы, например, система печати.