Самодел 2 (1114717), страница 11
Текст из файла (страница 11)
Понадобится целых 3 семафора: customers – подсчитывает количество посетителей, ожидающих в очереди, barbers – обозначает количество свободных парикмахеров (в случае одного парикмахера его значения либо 0, либо 1) и mutex – используется для синхронизации доступа к разделяемой переменной waiting. Переменная waiting, как и семафор customers, содержит количество посетителей, ожидающих в очереди, она используется в программе для того, чтобы иметь возможность проверить, имеется ли свободное кресло для ожидания, и при этом не заблокировать процесс, если кресла не окажется. Заметим, что, как и в предыдущем примере, эта переменная является разделяемым ресурсом, и доступ к ней охраняется семафором mutex.
#define CHAIRS 5
typedef int semaphore; /* некий семафор */
semaphore customers = 0; /* посетители, ожидающие в очереди */
semaphore barbers = 0; /* парикмахеры, ожидающие посетителей */
semaphore mutex = 1; /* контроль за доступом к переменной waiting */
int waiting = 0;
void barber(void)
{
while (true) {
down(customers); /* если customers == 0, т.е. посетителей нет, то заблокируемся до появления посетителя */
down(&mutex); /* получаем доступ к waiting */
waiting = wating – 1; /* уменьшаем кол-во ожидающих клиентов */
up(&barbers); /* парикмахер готов к работе */
up(&mutex); /* освобождаем ресурс waiting */
cut_hair(); /* процесс стрижки */
}
}
void customer(void)
{
down(&mutex); /* получаем доступ к waiting */
if (waiting < CHAIRS) /* есть место для ожидания */
{
waiting = waiting + 1; /* увеличиваем кол-во ожидающих клиентов */
up(&customers); /* если парикмахер спит, это его разбудит*/
up(&mutex); /* освобождаем ресурс waiting */
down(barbers); /* если парикмахер занят, переходим в состояние ожидания, иначе – занимаем парикмахера*/
get_haircut(); /* занять место и перейти к стрижке */
} else {
up(&mutex); /* нет свободного кресла для ожидания – придется уйти */
}
}
3. Реализация взаимодействия процессов
Неименованные какналы – фактически очерель сообщений. Может быть, что первый из процессов главный, а остальные – подчинённые по отношению к главному. Это значит, что набор прав и возможностей шире у главного, чем у подчинённых. Пример этого – отладчик и отлаживаемая программа.
Процессы могут быть любые, поэтому возникает проблема именования. Первая модель – общая память (например, RAM, файлы и т.д.). Вторая модель – непосредственное указание имени – здесь существуют разные модели реализации.
Именованные какналы – это аппараты ОС UNIX.
Взаимодействие процессов может быть растынуто по времени. Также, при взаимодействии процессов по сети нельзя обращаться к ним по именам – они могут быть одни и те же. В этой ситуации помогают разные средства. Это средства IPC – когда 2 и более процесса, сокеты – при конкретных процессах одной машины, MPI (Message Passing Interface) – интерфейс передачи сообщений.
Сигналы
Сигналы – это средства уведжомления процесса о наступлении некоторого события в системе. Инициаторами посылки сигналов могут быть другие процессы или сама ОС.
Сигналы – механизм асинхронного взаимодествия, момент прихода сигнала процессу заранее неизвестен. Сигнал, фактически, - это сообщение, которое может быть проинициировано в процессе чдром системы от имени другого процесса. Каждая вариация ОС UNIX имеет фиксированный набор сигналов, описанный в signal.h. Есть и набор сигналов, которые являются общими для любой вариации (SIGINT, SIGKILL). Примеры сигналов:
SIGINT (2) (Ctrl+C – мягкое завершение)
SIGQUIT (3)
SIGKILL (9) (жёсткое завершение)
SIGALRM (14)
SIGCHLD (18)
Все сигналы обрабатываются процессом-получателем по фиксированной схеме:
-
Нет описания – процесс завершается. Если процесс не трассируется, то может быть приостановка.
-
Если не прошла обработка сигнала по умолчанию, то вызвается функция – обработчик.
-
Третий вариант - игнорирование сигнала.
Схема:
Например, сигнал SIGINT можно перехватить, а сигнал SIGKILL нельзя.
Если процессу пришло несколько сигналов одноверменно, то порядок их обработки не определён. Если приходит 2 и более одиноковых сигналов, то здесь результат тоже зависит от ОС – сколько сигналов будет обрабатываться – все или один.
Приход сигнала может быть отложен до возврата из системного вызова либо системынй вызов завершается с кордом «–1».
Работа с сигналом
#include <sys/types.h>
#include <signal.h>
Для посылки сигнала используется функция:
Для посылки сигнала используется:
int kill (pit_t pid, int sig);
pid – идентификатор процесса, которому посылается сигнал
sig – номер посылаемого сигнала
При удачном выполнении возвращает 0, в противном случае возвращает –1
Для установки определённой реакции процесса на сигнал используется функция:
void (*signal ( int sig, void (*disp) (int))) (int)
sig –номер сигнала, для которого устанавливается реакция
disp – либо определенная пользователем функция – обработчик сигнала, либо одна из констант:
SIG_DFL – обработка по умолчанию
SIG_IGN - игнорирование
При успешном завершении функция возвращает указатель на предыдущий обработчик данного сигнала.
Примеры:
В данном примере при получении сигнала SIGINT четырежды вызывается специальный обработчик, а в пятый раз происходит обработка по умолчанию.
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
int count=1;
void SigHndlr (int s) /* обработчик сигнала */
{
printf("\n I got SIGINT %d time(s) \n", count ++);
if (count==5) signal (SIGINT, SIG_DFL); /* ставим обработчик сигнала по умолчанию */
else signal (SIGINT, SigHndlr); /* восстанавливаем обработчик сигнала*/
}
int main(int argc, char **argv)
{
signal (SIGINT, SigHndlr); /* установка реакции на сигнал*/
while (1);
/* ”тело программы” */
return 0;
}
При разработке программ нередко приходится создавать временные файлы, которые позже удаляются. Если произошло непредвиденное событие, такие файлы могут остаться неударенными. Чаще всего для удаления временного файла используется функция unlink(…). Ниже приведено решение этой задачи.
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
const char * tempfile = “abc”;
void SigHndlr (int s)
{
unlink(tempfile);
/* уничтожение временного файла в случае прихода сигнала SIGINT. В случае, если такой файл не существует (еще не создан или уже удален), вызов вернет -1 */
}
int main(int argc, char **argv)
{
signal(SIGINT, SigHndlr);
/*установка реакции на сигнал */
creat(tempfile, 0666); /*создание временного файла*/
unlink(tempfile);
/*уничтожение временного файла в случае нормального функционирования процесса */
return 0;
}
Вот ещё один пример – программа «Будильник» - однопроцессный и двухпроцессный варианты.
-
Однопроцессный вариант.
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
void alrm (int s) /*обработчик сигнала SIG_ALRM */
{
printf(“\n жду имя \n”);
alarm(5); /* заводим будильник */
signal (SIGALRM, alrm); /* перестанавливаем реакцию на сигал*/
}
int main(int argc, char **argv)
{
char s[80];
signal(SIGALRM, alrm);
/* установка обработчика alrm на приход сигнала SIG_ALRM */
alarm(5); /* заводим будильник */
printf(“Введите имя \n”);
for (;;)
{
printf(“имя:”);
if (gets(s) != NULL) break; /* ожидаем ввода имени */
};
printf(“OK! \n”);
return 0;
}
В начале программы мы устанавливаем реакцию на сигнал SIGALRM - функцию alarm(), далее мы заводим будильник, запрашиваем “Введите имя” и ожидаем ввода строки символов. Если ввод строки задерживается, то будет вызвана функция alarm(), которая напомнит, что программа “ждет имя”, опять заведет будильник и поставит себя на обработку сигнала SIGALRM еще раз. И так будет до тех пор, пока не будет введена строка. Здесь имеется один нюанс: если в момент выполнения системного вызова возникает событие, связанное с сигналом, то система прерывает выполнение системного вызова и возвращает код ответа, равный «-1».
-
Двухпроцессный вариант.
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
void alr(int s)
{
printf(“\n Быстрее!!! \n”);
signal (SIGALRM, alr);
/* переустановка обработчика alr на приход сигнала SIGALRM */
}
int main(int argc, char **argv)
{
char s[80];
int pid;
signal(SIGALRM, alr);
/* установка обработчика alr на приход сигнала SIGALRM */
if (pid=fork()) {
for (;;)
{
sleep(5); /*приостанавливаем процесс на 5 секунд */
kill(pid, SIGALRM);
/*отправляем сигнал SIGALRM процессу-сыну */
}
}
else {
printf(“Введите имя \n”);
for (;;)
{
printf(“имя:”);
if ( gets(s) != NULL ) break; /*ожидаем ввода имени*/
}
printf(“OK!\n”);
kill(getppid(), SIGKILL);
/* убиваем зациклившегося отца */
}
return 0;
}
В данном случае программа реализуется в двух процессах. Как и в предыдущем примере, имеется функция реакции на сигнал alr(), которая выводит на экран сообщение и переустанавливает функцию реакции на сигнал, опять же на себя. В основной программе мы также указываем alr() как реакцию на SIGALRM. После этого мы запускаем сыновний процесс, и отцовский процесс (бесконечный цикл) “засыпает” на 5 единиц времени, после чего сыновнему процессу будет отправлен сигнал SIGALRM. Все, что ниже цикла, будет выполняться в процессе-сыне: мы ожидаем ввода строки, если ввод осуществлен, то происходит уничтожение отца (SIGKILL).Примечание: При таком использовании функции kill: kill(pid, SIGALRM), если аргумент pid равен нулю, то этот сигнал отправится всей группе.
Неименованные каналы.
Одним из простейших средств взаимодействия процессов в операционной системе UNIX является механизм каналов. Неименованный канал есть некая сущность, в которую можно помещать и извлекать данные, для чего служат два файловых дескриптора, ассоциированных с каналом: один для записи в канал, другой — для чтения.
Отличительные свойства.
•Невозможен доступ по имени (доступ только по файловым дескрипторам)
•Канал не существует вне процесса
•Реализуется модель последовательного дотупа к данным (FIFO)
Для создания канала служит системный вызов pipe():
int pipe (int *fd)
Данный системный вызов выделяет в оперативной памяти некоторое ограниченное пространство и возвращает че6рез параметр fd массив из двух файловых дескрипторов: один для записи в канал — fd[1], другой для чтения — fd[0].
Эти дескрипторы являются дескрипторами открытых файлов, с которыми можно работать, используя такие системные вызовы как read(), write(), dup() и пр.
Однако существуют различия в организации использования обычного файла и канала.
Особенности организации чтения из канала и записи в канал:
Чтение:
если прочитано меньше байтов, чем находится в канале, оставшиеся сохраняются в канале;
если делается попытка прочитать больше данных, чем имеется в канале:
недостаточно данных
существуют открытые дескрипторы записи, ассоциированные с каналом - следовательно, будет прочитано (т.е. изъято из канала) доступное количество данных, после чего читающий процесс блокируется до тех пор, пока в канале не появится достаточное количество данных для завершения операции чтения;
…… процесс может избежать такого блокирования, изменив для канала режим блокировки с использованием системного вызова fcntl(), в этом случае будет считано доступное количество данных, и управление будет сразу возвращено процессу;
……при закрытии записывающей стороны канала, в него помещается символ EOF (т.е. ситуация когда закрыты все дескрипторы, ассоциированные с записью в канал), после этого процесс, осуществляющий чтение, может выбрать из канала все оставшиеся данные и признак конца файла, благодаря которому блокирования при чтении в этом случае не происходит.
При записи в канал происходит примерно то же самое, аналогична ситуация с блокировкой при попытке записать в канал больше, чем туда поместится (но не более предельного размера канала), есть и нюансы:
если процесс пытается записать в канал порцию данных, превышающую предельный размер канала, то будет записано доступное количество данных, после чего процесс заблокируется до появления в канале свободного места любого размера (пусть даже и всего 1 байт), затем процесс разблокируется, вновь производит запись на доступное место в канале, и если данные для записи еще не исчерпаны, вновь блокируется до появления свободного места и т.д., пока не будут записаны все данные, после чего происходит возврат из вызова write()
если процесс пытается осуществить запись в канал, с которым не ассоциирован ни один дескриптор чтения, то он получает сигнал SIGPIPE – некорректная работа с каналом (тем самым ОС уведомляет его о недопустимости такой операции).
![](https://s.studizba.com/z.php?f=/templates/si/i/noavatar.png&w=100&h=100&t=1"){kind=avatar}
