Вордовские лекции (1115151), страница 13
Текст из файла (страница 13)
Пример. Обработка сигнала.
В данном примере при получении сигнала 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;
}
Пример. Удаление временных файлов при завершении программы.
При разработке программ нередко приходится создавать временные файлы , которые позже удаляются. Если произошло непредвиденное событие, такие файлы могут остаться неудаленными. Ниже приведено решение этой задачи.
#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;
}
В данном примере для создания временного файла используется системный вызов creat():
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int creat(const char *pathname, mode_t mode);
А системный вызов unlink() удаляет имя и файл, на который оно ссылается.
#include <unistd.h>
int unlink(const char *pathname);
Пример. Программа “Будильник”.
Программа “Будильник”. Средствами ОС “заводится” будильник, который будет поторапливать ввести некоторое имя. Системный вызов alarm():
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
инициализирует появление сигнала SIGALRM - процесс запрашивает ядро отправить сигнал по прошествии определенного времени.
#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).
6.2.2Неименованные каналы.
Одним из простейших средств взаимодействия процессов в операционной системе UNIX является механизм каналов. Неименованный канал есть некая сущность, в которую можно помещать и извлекать данные, для чего служат два файловых дескриптора, ассоциированных с каналом: один для записи в канал, другой — для чтения. Для создания канала служит системный вызов pipe():
int pipe (int *fd)
Данный системный вызов выделяет в оперативной памяти некоторое ограниченное пространство и возвращает че6рез параметр fd массив из двух файловых дескрипторов: один для записи в канал — fd[1], другой для чтения — fd[0].
Эти дескрипторы являются дескрипторами открытых файлов, с которыми можно работать, используя такие системные вызовы как read(), write(), dup() и пр.
Однако существуют различия в организации использования обычного файла и канала.
Особенности организации чтения данных из канала:
-
если прочитано меньше байтов, чем находится в канале, оставшиеся сохраняются в канале;
-
если делается попытка прочитать больше данных, чем имеется в канале, и при этом существуют открытые дескрипторы записи, ассоциированные с каналом, будет прочитано (т.е. изъято из канала) доступное количество данных, после чего читающий процесс блокируется до тех пор, пока в канале не появится достаточное количество данных для завершения операции чтения;
-
процесс может избежать такого блокирования, изменив для канала режим блокировки с использованием системного вызова fcntl(), в этом случае будет считано доступное количество данных, и управление будет сразу возвращено процессу;
-
при закрытии записывающей стороны канала, в него помещается символ EOF (т.е. ситуация когда закрыты все дескрипторы, ассоциированные с записью в канал), после этого процесс, осуществляющий чтение, может выбрать из канала все оставшиеся данные и признак конца файла, благодаря которому блокирования при чтении в этом случае не происходит.
Особенности организации записи данных в канал:
-
если процесс пытается записать большее число байтов, чем помещается в канал (но не превышающее предельный размер канала) записывается возможное количество данных, после чего процесс, осуществляющий запись, блокируется до тех пор, пока в канале не появится достаточное количество места для завершения операции записи;
-
процесс может избежать такого блокирования, изменив для канала режим блокировки с использованием системного вызова fcntl(). В неблокирующем режиме в ситуации, описанной выше, будет записано возможное количество данных, и управление будет сразу возвращено процессу.
-
если же процесс пытается записать в канал порцию данных, превышающую предельный размер канала, то будет записано доступное количество данных, после чего процесс заблокируется до появления в канале свободного места любого размера (пусть даже и всего 1 байт), затем процесс разблокируется, вновь производит запись на доступное место в канале, и если данные для записи еще не исчерпаны, вновь блокируется до появления свободного места и т.д., пока не будут записаны все данные, после чего происходит возврат из вызова write()
-
если процесс пытается осуществить запись в канал, с которым не ассоциирован ни один дескриптор чтения, то он получает сигнал SIGPIPE (тем самым ОС уведомляет его о недопустимости такой операции).
В стандартной ситуации (при отсутствии переполнения) система гарантирует атомарность операции записи, т. е. при одновременной записи нескольких процессов в канал их данные не перемешиваются.
Пример. Использование канала.
Пример использования канала в рамках одного процесса – копирование строк. Фактически осуществляется посылка данных самому себе.
int main(int argc, char **argv)
{
char s*=”chanel”;
char buf[80];
int pipes[2];
pipe(pipes);
write(pipes[1],s,strlen(s)+1);
read(pipes[0],buf,strlen(s)+1);
close(pipes[0]);
close(pipes[1]);
printf(“%s\n”,buf);
}
Рис. 9 Обмен через канал в рамках одного процесса.
Чаще всего, однако, канал используется для обмена данными между несколькими процессами. При организации такого обмена используется тот факт, что при порождении сыновнего процесса посредством системного вызова fork() наследуется таблица файловых дескрипторов процесса-отца, т.е. все файловые дескрипторы, доступные процессу-отцу, будут доступны и процессу-сыну. Таким образом, если перед порождением потомка был создан канал, файловые дескрипторы для доступа к каналу будут унаследованы и сыном. В итоге обоим процессам оказываются доступны дескрипторы, связанные с каналом, и они могут использовать канал для обмена данными (см. рис. 10 и пример 14).
Рис. 10 Пример обмена данными между процессами через канал.
Пример. Схема взаимодействия процессов с использованием канала.
int main(int argc, char **argv)
{
int fd[2];
pipe(fd);
if(fork())
{/*процесс-родитель*/
close(fd[0]); /* закрываем ненужный дескриптор */
write (fd[1], …);
…
close(fd[1]);
…
}
else
{/*процесс-потомок*/
close(fd[1]); /* закрываем ненужный дескриптор */
while(read (fd[0], …))
{
…
}
…
}
}
Аналогичным образом может быть организован обмен через канал между двумя потомками одного порождающего процесса и вообще между любыми родственными процессами, единственным требованием здесь, как уже говорилось, является необходимость создавать канал в порождающем процессе прежде, чем его дескрипторы будут унаследованы порожденными процессами.
Как правило, канал используется как однонаправленное средство передачи данных, т.е. только один из двух взаимодействующих процессов осуществляет запись в него, а другой процесс осуществляет чтение3, при этом каждый из процессов закрывает не используемый им дескриптор. Это особенно важно для неиспользуемого дескриптора записи в канал, т.к. именно при закрытии пишущей стороны канала в него помещается символ конца файла. Если, к примеру, в рассмотренном примере 14 процесс-потомок не закроет свой дескриптор записи в канал, то при последующем чтении из канала, исчерпав все данные из него, он будет заблокирован, т.к. записывающая сторона канала будет открыта, и следовательно, читающий процесс будет ожидать очередной порции данных.
Пример. Реализация конвейера.
Пример реализации конвейера print|wc – вывод программы print будет подаваться на вход программы wc. Программа print печатает некоторый текст. Программа wc считает количество прочитанных строк, слов и символов.
#include <stdio.h>
![](https://s.studizba.com/z.php?f=/templates/si/i/noavatar.png&w=100&h=100&t=1"){kind=avatar}
